GVariant *
ostree_zlib_file_header_new (GFileInfo *file_info,
GVariant *xattrs)
{
guint64 size;
guint32 uid;
guint32 gid;
guint32 mode;
guint32 rdev;
const char *symlink_target;
GVariant *ret;
ot_lvariant GVariant *tmp_xattrs = NULL;
size = g_file_info_get_size (file_info);
uid = g_file_info_get_attribute_uint32 (file_info, "unix::uid");
gid = g_file_info_get_attribute_uint32 (file_info, "unix::gid");
mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode");
rdev = g_file_info_get_attribute_uint32 (file_info, "unix::rdev");
if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_SYMBOLIC_LINK)
symlink_target = g_file_info_get_symlink_target (file_info);
else
symlink_target = "";
if (xattrs == NULL)
tmp_xattrs = g_variant_ref_sink (g_variant_new_array (G_VARIANT_TYPE ("(ayay)"), NULL, 0));
ret = g_variant_new ("(tuuuus@a(ayay))",
GUINT64_TO_BE (size), GUINT32_TO_BE (uid),
GUINT32_TO_BE (gid), GUINT32_TO_BE (mode), GUINT32_TO_BE (rdev),
symlink_target, xattrs ? xattrs : tmp_xattrs);
g_variant_ref_sink (ret);
return ret;
}
GVariant *
ostree_create_directory_metadata (GFileInfo *dir_info,
GVariant *xattrs)
{
GVariant *ret_metadata = NULL;
ret_metadata = g_variant_new ("(uuu@a(ayay))",
GUINT32_TO_BE (g_file_info_get_attribute_uint32 (dir_info, "unix::uid")),
GUINT32_TO_BE (g_file_info_get_attribute_uint32 (dir_info, "unix::gid")),
GUINT32_TO_BE (g_file_info_get_attribute_uint32 (dir_info, "unix::mode")),
xattrs ? xattrs : g_variant_new_array (G_VARIANT_TYPE ("(ayay)"), NULL, 0));
g_variant_ref_sink (ret_metadata);
return ret_metadata;
}
gboolean
arv_fake_camera_write_register (ArvFakeCamera *camera, guint32 address, guint32 value)
{
guint32 be_value = GUINT32_TO_BE (value);
return arv_fake_camera_write_memory (camera, address, sizeof (value), &be_value);
}
static PersistEntryHandle
_alloc_value(PersistState *self, guint32 orig_size, gboolean in_use, guint8 version)
{
PersistEntryHandle result;
PersistValueHeader *header;
guint32 size = orig_size;
/* round up size to 8 bytes boundary */
if ((size & 0x7))
size = ((size >> 3) + 1) << 3;
if (self->current_ofs + size + sizeof(PersistValueHeader) > self->current_size)
{
if (!_grow_store(self, self->current_size + sizeof(PersistValueHeader) + size))
return 0;
}
result = self->current_ofs + sizeof(PersistValueHeader);
/* fill value header */
header = (PersistValueHeader *) persist_state_map_entry(self, self->current_ofs);
header->size = GUINT32_TO_BE(orig_size);
header->in_use = in_use;
header->version = version;
persist_state_unmap_entry(self, self->current_ofs);
self->current_ofs += size + sizeof(PersistValueHeader);
return result;
}
guint64
prop_copy_uint32 (guint32 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
prop = GUINT32_TO_BE (prop);
return copy_func (&prop, sizeof (guint32), buffer, size, offset);
}
static void setblock(struct blockinfo * b, unsigned char * blockbuffer)
{
memset(blockbuffer, 0, HIMD_BLOCKINFO_SIZE);
setbeword32(blockbuffer, GUINT32_TO_BE(b->type)); /* ensure to use big endian on all platforms */
setbeword16(blockbuffer+4, b->nframes);
setbeword16(blockbuffer+6, b->mcode);
setbeword16(blockbuffer+8, b->lendata);
setbeword32(blockbuffer+12, b->serial_number);
memcpy(blockbuffer+16, &b->key, 8);
memcpy(blockbuffer+24, &b->iv, 8);
memcpy(blockbuffer+32, &b->audio_data, HIMD_AUDIO_SIZE);
setbeword32(blockbuffer+16368, GUINT32_TO_BE(b->backup_type));
setbeword16(blockbuffer+16374, b->backup_mcode);
setbeword32(blockbuffer+16376, b->lo32_contentid);
setbeword32(blockbuffer+16380, b->backup_serial_number);
}
static void
cockpit_pipe_transport_send (CockpitTransport *transport,
guint channel,
GBytes *payload)
{
CockpitPipeTransport *self = COCKPIT_PIPE_TRANSPORT (transport);
GBytes *prefix;
gchar *prefix_str;
gsize prefix_len;
guint32 size;
prefix_str = g_strdup_printf ("xxxx%u\n", channel);
prefix_len = strlen (prefix_str);
/* See doc/protocol.md */
size = GUINT32_TO_BE (g_bytes_get_size (payload) + prefix_len - 4);
memcpy (prefix_str, &size, 4);
prefix = g_bytes_new_take (prefix_str, prefix_len);
cockpit_pipe_write (self->pipe, prefix);
cockpit_pipe_write (self->pipe, payload);
g_bytes_unref (prefix);
g_debug ("%s: queued %d byte payload", self->name, (int)g_bytes_get_size (payload));
}
static void process(GChecksum *ctx)
{
uint32_t data[16];
for (size_t i = 0; i < 16; ++i)
data[i] = GUINT32_TO_BE(ctx->buffer.u32[i]);
transform(ctx->sha256.state, data);
}
void
lx_print_uint32(RxBuffer *buf, guint32 value, GError **error)
{
g_assert(buf != NULL); g_assert(buf->array != NULL);
g_assert(error != NULL);
guint32 network_value = GUINT32_TO_BE(value);
g_byte_array_append(buf->array, (guint8*)&network_value, sizeof(network_value));
}
static void
set_uint32 (GString *s, guint32 offset, guint32 val)
{
union {
guint32 as_int;
char as_bytes[4];
} u;
u.as_int = GUINT32_TO_BE (val);
memcpy (s->str + offset, u.as_bytes, 4);
}
static gboolean
send_request_sync (GOutputStream *output,
DsiCommand command,
guint16 request_id,
guint32 writeOffset,
gsize len,
const char *data,
GCancellable *cancellable,
GError **error)
{
DSIHeader dsi_header;
gboolean res;
gsize write_count, bytes_written;
dsi_header.flags = 0x00;
dsi_header.command = command;
dsi_header.requestID = GUINT16_TO_BE (request_id);
dsi_header.writeOffset = GUINT32_TO_BE (writeOffset);
dsi_header.totalDataLength = GUINT32_TO_BE (len);
dsi_header.reserved = 0;
write_count = sizeof (DSIHeader);
res = g_output_stream_write_all (output, &dsi_header, write_count,
&bytes_written, cancellable, error);
if (!res)
return FALSE;
if (data == NULL)
return TRUE;
write_count = len;
res = g_output_stream_write_all (output, data, write_count, &bytes_written,
cancellable, error);
if (!res)
return FALSE;
return TRUE;
}
static void
draw_rect_ARGB (guchar * pixels[3],
guint stride[3], gint x, gint y, guint width, guint height, guint32 color)
{
guint i, j;
color = GUINT32_TO_BE (color);
for (j = 0; j < height; j++) {
guint32 *p = (guint32 *) (pixels[0] + (y + j) * stride[0] + x * 4);
for (i = 0; i < width; i++)
p[i] = color;
}
}
static bool_t write_header (VFSFile * handle, int size, bool_t is_footer)
{
ID3v2Header header;
memcpy (header.magic, is_footer ? "3DI" : "ID3", 3);
header.version = 4;
header.revision = 0;
header.flags = ID3_HEADER_HAS_FOOTER;
header.size = syncsafe32 (size);
header.size = GUINT32_TO_BE (header.size);
return vfs_fwrite (& header, 1, sizeof (ID3v2Header), handle) == sizeof
(ID3v2Header);
}
/**
* facq_stream_data_to_checksum:
* @stmd: A #FacqStreamData object.
* @sum: A #GChecksum object.
*
* Dumps all the attributes of the #FacqStreamData, trough the #GChecksum, @sum
* object, using g_checksum_update().
*/
void facq_stream_data_to_checksum(const FacqStreamData *stmd,GChecksum *sum){
guint32 tmp = 0, i = 0;
guint *channels = NULL;
FacqUnits *units = NULL;
gdouble tmpd = 0, *max = NULL , *min = NULL;
g_return_if_fail(sum);
g_return_if_fail(FACQ_IS_STREAM_DATA(stmd));
tmpd = stmd->period;
tmpd = GDOUBLE_TO_BE(tmpd);
g_checksum_update(sum,(guchar *)&tmpd,sizeof(gdouble));
tmp = stmd->n_channels;
tmp = GUINT32_TO_BE(tmp);
g_checksum_update(sum,(guchar *)&tmp,sizeof(guint32));
channels = facq_chanlist_to_comedi_chanlist(stmd->chanlist,NULL);
for(i = 0;i < stmd->n_channels;i++){
tmp = GUINT32_TO_BE(channels[i]);
g_checksum_update(sum,(guchar *)&tmp,sizeof(guint32));
}
g_free(channels);
units = stmd->units;
for(i = 0;i < stmd->n_channels;i++){
tmp = GUINT32_TO_BE(units[i]);
g_checksum_update(sum,(guchar *)&tmp,sizeof(guint32));
}
max = stmd->max;
for(i = 0;i < stmd->n_channels;i++){
tmpd = GDOUBLE_TO_BE(max[i]);
g_checksum_update(sum,(guchar *)&tmpd,sizeof(gdouble));
}
min = stmd->min;
for(i = 0;i < stmd->n_channels;i++){
tmpd = GDOUBLE_TO_BE(min[i]);
g_checksum_update(sum,(guchar *)&tmpd,sizeof(gdouble));
}
}
gboolean
ostree_write_variant_with_size (GOutputStream *output,
GVariant *variant,
guint64 alignment_offset,
gsize *out_bytes_written,
GChecksum *checksum,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
guint64 variant_size;
guint32 variant_size_u32_be;
gsize bytes_written;
gsize ret_bytes_written = 0;
/* Write variant size */
variant_size = g_variant_get_size (variant);
g_assert (variant_size < G_MAXUINT32);
variant_size_u32_be = GUINT32_TO_BE((guint32) variant_size);
bytes_written = 0;
if (!ot_gio_write_update_checksum (output, &variant_size_u32_be, 4,
&bytes_written, checksum,
cancellable, error))
goto out;
ret_bytes_written += bytes_written;
alignment_offset += bytes_written;
bytes_written = 0;
/* Pad to offset of 8, write variant */
if (!write_padding (output, 8, alignment_offset, &bytes_written, checksum,
cancellable, error))
goto out;
ret_bytes_written += bytes_written;
bytes_written = 0;
if (!ot_gio_write_update_checksum (output, g_variant_get_data (variant),
variant_size, &bytes_written, checksum,
cancellable, error))
goto out;
ret_bytes_written += bytes_written;
ret = TRUE;
if (out_bytes_written)
*out_bytes_written = ret_bytes_written;
out:
return ret;
}
void falcon_object_save(trie_node_t *node, void *userdata)
{
const falcon_object_t *object = (const falcon_object_t *)trie_data(node);
int fd = GPOINTER_TO_INT(userdata);
guint16 len = strlen(object->name);
guint16 len_be = GUINT16_TO_BE(len);
guint64 size = GUINT64_TO_BE(object->size);
guint64 time = GUINT64_TO_BE(object->time);
guint32 mode = GUINT32_TO_BE(object->mode);
if (write(fd, &len_be, 2) == -1 || write(fd, object->name, len) == -1
|| write(fd, &size, 8) == -1 || write(fd, &time, 8) == -1
|| write(fd, &mode, 4) == -1 || write(fd, &(object->watch), 1) == -1)
g_critical(_("Failed to save object \"%s\": %s"), object->name,
g_strerror(errno));
}
static GString *
append_uint32 (GString *s, guint32 val, guint32 *offset)
{
union {
guint32 as_int;
char as_bytes[4];
} u;
if (offset)
*offset = s->len;
u.as_int = GUINT32_TO_BE (val);
g_string_append_len (s, u.as_bytes, 4);
return s;
}
/* function to load v2 and v3 format persistent files */
static gboolean
_load_v23(PersistState *self, gint version, SerializeArchive *sa)
{
gchar *key, *value;
while (serialize_read_cstring(sa, &key, NULL))
{
gsize len;
guint32 str_len;
if (key[0] && serialize_read_cstring(sa, &value, &len))
{
gpointer new_block;
PersistEntryHandle new_handle;
/* add length of the string */
new_handle = _alloc_value(self, len + sizeof(str_len), FALSE, version);
new_block = persist_state_map_entry(self, new_handle);
/* NOTE: we add an extra length field to the old value, as our
* persist_state_lookup_string() needs that.
* persist_state_lookup_string is used to fetch disk queue file
* names. It could have been solved somewhat better, but now it
* doesn't justify a persist-state file format change.
*/
str_len = GUINT32_TO_BE(len);
memcpy(new_block, &str_len, sizeof(str_len));
memcpy(new_block + sizeof(str_len), value, len);
persist_state_unmap_entry(self, new_handle);
/* add key to the current file */
_add_key(self, key, new_handle);
g_free(value);
g_free(key);
}
else
{
g_free(key);
break;
}
}
return TRUE;
}
/**
* qmi_utils_write_guint32_to_buffer:
* @buffer: a buffer.
* @buffer_size: size of @buffer.
* @endian: endianness of firmware value; swapped from host byte order if necessary
* @in: location of the variable to be written.
*
* Writes an unsigned 32-bit integer into the buffer. The number to be written
* is expected to be given in host endianness, and this method takes care of
* converting the value written to the byte order specified by @endian.
*
* The user needs to make sure that the buffer is at least 4 bytes long.
*
* Also note that both @buffer and @buffer_size get updated after the 4 bytes
* write.
*/
void
qmi_utils_write_guint32_to_buffer (guint8 **buffer,
guint16 *buffer_size,
QmiEndian endian,
guint32 *in)
{
guint32 tmp;
g_assert (in != NULL);
g_assert (buffer != NULL);
g_assert (buffer_size != NULL);
g_assert (*buffer_size >= 4);
if (endian == QMI_ENDIAN_BIG)
tmp = GUINT32_TO_BE (*in);
else
tmp = GUINT32_TO_LE (*in);
memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
*buffer = &((*buffer)[4]);
*buffer_size = (*buffer_size) - 4;
}
static bool_t write_frame (VFSFile * handle, GenericFrame * frame, int *
frame_size)
{
TAGDBG ("Writing frame %s, size %d\n", frame->key, frame->size);
ID3v2FrameHeader header;
memcpy (header.key, frame->key, 4);
header.size = syncsafe32 (frame->size);
header.size = GUINT32_TO_BE (header.size);
header.flags = 0;
if (vfs_fwrite (& header, 1, sizeof (ID3v2FrameHeader), handle) != sizeof
(ID3v2FrameHeader))
return FALSE;
if (vfs_fwrite (frame->data, 1, frame->size, handle) != frame->size)
return FALSE;
* frame_size = sizeof (ID3v2FrameHeader) + frame->size;
return TRUE;
}
static gboolean
flow_foo_serialize_step (FlowFoo *foo, FlowPacketQueue *packet_queue, SerializeContext *context)
{
FlowPacket *packet;
FlowFooPrivate *priv = foo->priv;
union
{
guint32 n_be;
guchar b [4];
}
u;
if (context->n == 4)
return FALSE;
u.n_be = GUINT32_TO_BE (priv->test_int);
packet = flow_packet_new (FLOW_PACKET_FORMAT_BUFFER, &u.b [context->n], 1);
context->n++;
flow_packet_queue_push_packet (packet_queue, packet);
return TRUE;
}
static void
cockpit_ssh_transport_send (CockpitTransport *transport,
const gchar *channel,
GBytes *payload)
{
CockpitSshTransport *self = COCKPIT_SSH_TRANSPORT (transport);
gchar *prefix;
gsize length;
guint32 size;
g_return_if_fail (!self->closing);
prefix = g_strdup_printf ("xxxx%s\n", channel ? channel : "");
length = strlen (prefix);
/* See doc/protocol.md */
size = GUINT32_TO_BE (g_bytes_get_size (payload) + length - 4);
memcpy (prefix, &size, 4);
g_queue_push_tail (self->queue, g_bytes_new_take (prefix, length));
g_queue_push_tail (self->queue, g_bytes_ref (payload));
g_debug ("%s: queued %d byte payload", self->logname, (int)g_bytes_get_size (payload));
}
gboolean
qdisk_push_tail(QDisk *self, GString *record)
{
guint32 n = GUINT32_TO_BE(record->len);
/* write follows read (e.g. we are appending to the file) OR
* there's enough space between write and read.
*
* If write follows read we need to check two things:
* - either we are below the maximum limit (GINT64_FROM_BE(self->hdr->write_head) < self->options->disk_buf_size)
* - or we can wrap around (GINT64_FROM_BE(self->hdr->read_head) != QDISK_RESERVED_SPACE)
* If neither of the above is true, the buffer is full.
*/
if (!qdisk_is_space_avail(self, record->len))
return FALSE;
if (n == 0)
{
msg_error("Error writing empty message into the disk-queue file");
return FALSE;
}
if (!pwrite_strict(self->fd, (gchar *) &n, sizeof(n), self->hdr->write_head) ||
!pwrite_strict(self->fd, record->str, record->len, self->hdr->write_head + sizeof(n)))
{
msg_error("Error writing disk-queue file",
evt_tag_errno("error", errno));
return FALSE;
}
self->hdr->write_head = self->hdr->write_head + record->len + sizeof(n);
/* NOTE: we only wrap around if the read head is before the write,
* otherwise we'd truncate the data the read head is still processing, e.g.
*
* start limit file size
* | | |
* ^ read ^write
*
* We can truncate in the scenario above, once we surpass the limit,
* however if this is the case:
*
* start limit file size
* | | |
* ^write ^read
*
* In this case cannot wrap around, even if the limit is surpassed, as
* in that case data still unprocessed by the read head would be lost.
* This can happen if the size of the queue file got decreased while
* it still had more data.
* */
/* NOTE: if these were equal, that'd mean the queue is empty, so we spoiled something */
g_assert(self->hdr->write_head != self->hdr->backlog_head);
if (self->hdr->write_head > MAX(self->hdr->backlog_head,self->hdr->read_head))
{
if (self->file_size > self->hdr->write_head)
{
_truncate_file(self, self->hdr->write_head);
}
self->file_size = self->hdr->write_head;
if (self->hdr->write_head > self->options->disk_buf_size && self->hdr->backlog_head != QDISK_RESERVED_SPACE)
{
/* we were appending to the file, we are over the limit, and space
* is available before the read head. truncate and wrap.
*
* Otherwise we let the write_head over size limits for a bit and
* for the next message, the condition at the beginning of this
* function will cause the push to fail */
self->hdr->write_head = QDISK_RESERVED_SPACE;
}
}
self->hdr->length++;
return TRUE;
}
static gboolean
gst_genicamsrc_start (GstBaseSrc * bsrc)
{
GstGenicamSrc *src = GST_GENICAM_SRC (bsrc);
GC_ERROR ret;
uint32_t i, num_ifaces, num_devs;
guint32 width, height, bpp, stride;
GstVideoInfo vinfo;
GST_DEBUG_OBJECT (src, "start");
/* bind functions from CTI */
if (!gst_genicamsrc_bind_functions (src)) {
GST_ELEMENT_ERROR (src, LIBRARY, INIT,
("GenTL CTI could not be opened: %s", g_module_error ()), (NULL));
return FALSE;
}
/* initialize library and print info */
ret = GTL_GCInitLib ();
HANDLE_GTL_ERROR ("GenTL Producer library could not be initialized");
gst_genicam_print_gentl_impl_info (src);
/* open GenTL, print info, and update interface list */
ret = GTL_TLOpen (&src->hTL);
HANDLE_GTL_ERROR ("System module failed to open");
gst_genicam_print_system_info (src);
ret = GTL_TLUpdateInterfaceList (src->hTL, NULL, src->timeout);
HANDLE_GTL_ERROR ("Failed to update interface list within timeout");
/* print info for all interfaces and open specified interface */
ret = GTL_TLGetNumInterfaces (src->hTL, &num_ifaces);
HANDLE_GTL_ERROR ("Failed to get number of interfaces");
if (num_ifaces > 0) {
GST_DEBUG_OBJECT (src, "Found %dGenTL interfaces", num_ifaces);
for (i = 0; i < num_ifaces; ++i) {
gst_genicam_print_interface_info (src, i);
}
} else {
GST_ELEMENT_ERROR (src, LIBRARY, FAILED, ("No interfaces found"), (NULL));
goto error;
}
if (!src->interface_id || src->interface_id[0] == 0) {
size_t id_size;
GST_DEBUG_OBJECT (src, "Trying to find interface ID at index %d",
src->interface_index);
ret = GTL_TLGetInterfaceID (src->hTL, src->interface_index, NULL, &id_size);
HANDLE_GTL_ERROR ("Failed to get interface ID at specified index");
if (src->interface_id) {
g_free (src->interface_id);
}
src->interface_id = (gchar *) g_malloc (id_size);
ret =
GTL_TLGetInterfaceID (src->hTL, src->interface_index, src->interface_id,
&id_size);
HANDLE_GTL_ERROR ("Failed to get interface ID at specified index");
}
GST_DEBUG_OBJECT (src, "Trying to open interface '%s'", src->interface_id);
ret = GTL_TLOpenInterface (src->hTL, src->interface_id, &src->hIF);
HANDLE_GTL_ERROR ("Interface module failed to open");
ret = GTL_IFUpdateDeviceList (src->hIF, NULL, src->timeout);
HANDLE_GTL_ERROR ("Failed to update device list within timeout");
/* print info for all devices and open specified device */
ret = GTL_IFGetNumDevices (src->hIF, &num_devs);
HANDLE_GTL_ERROR ("Failed to get number of devices");
if (num_devs > 0) {
for (i = 0; i < num_devs; ++i) {
gst_genicam_print_device_info (src, i);
}
} else {
GST_ELEMENT_ERROR (src, LIBRARY, FAILED,
("No devices found on interface"), (NULL));
goto error;
}
if (!src->device_id || src->device_id[0] == 0) {
size_t id_size;
GST_DEBUG_OBJECT (src, "Trying to find device ID at index %d",
src->device_index);
GTL_IFGetDeviceID (src->hIF, src->device_index, NULL, &id_size);
HANDLE_GTL_ERROR ("Failed to get device ID at specified index");
if (src->device_id) {
g_free (src->device_id);
}
src->device_id = (gchar *) g_malloc (id_size);
GTL_IFGetDeviceID (src->hIF, src->device_index, src->device_id, &id_size);
HANDLE_GTL_ERROR ("Failed to get device ID at specified index");
}
GST_DEBUG_OBJECT (src, "Trying to open device '%s'", src->device_id);
ret =
GTL_IFOpenDevice (src->hIF, src->device_id, DEVICE_ACCESS_CONTROL,
&src->hDEV);
HANDLE_GTL_ERROR ("Failed to open device");
/* find and open specified data stream id */
if (!src->stream_id || src->stream_id[0] == 0) {
size_t id_size;
GST_DEBUG_OBJECT (src, "Trying to find stream ID at index %d",
src->stream_index);
GTL_DevGetDataStreamID (src->hDEV, src->stream_index, NULL, &id_size);
HANDLE_GTL_ERROR ("Failed to get stream ID at specified index");
if (src->stream_id) {
g_free (src->stream_id);
}
src->stream_id = (gchar *) g_malloc (id_size);
GTL_DevGetDataStreamID (src->hDEV, src->stream_index, src->stream_id,
&id_size);
HANDLE_GTL_ERROR ("Failed to get stream ID at specified index");
}
GST_DEBUG_OBJECT (src, "Trying to open data stream '%s'", src->stream_id);
ret = GTL_DevOpenDataStream (src->hDEV, src->stream_id, &src->hDS);
HANDLE_GTL_ERROR ("Failed to open data stream");
{
uint32_t num_urls = 0;
char url[2048];
size_t url_len = sizeof (url);
INFO_DATATYPE datatype;
const uint32_t url_index = 0;
ret = GTL_DevGetPort (src->hDEV, &src->hDevPort);
HANDLE_GTL_ERROR ("Failed to get port on device");
ret = GTL_GCGetNumPortURLs (src->hDevPort, &num_urls);
HANDLE_GTL_ERROR ("Failed to get number of port URLs");
GST_DEBUG_OBJECT (src, "Found %d port URLs", num_urls);
GST_DEBUG_OBJECT (src, "Trying to get URL index %d", url_index);
GTL_GCGetPortURLInfo (src->hDevPort, url_index, URL_INFO_URL, &datatype,
url, &url_len);
HANDLE_GTL_ERROR ("Failed to get URL");
GST_DEBUG_OBJECT (src, "Found URL '%s'", url);
g_assert (url_len > 6);
if (g_str_has_prefix (url, "file")) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("file url not supported yet"), (NULL));
goto error;
} else if (g_str_has_prefix (url, "local")) {
GError *err = NULL;
GMatchInfo *matchInfo;
GRegex *regex;
gchar *filename, *addr_str, *len_str;
uint64_t addr;
size_t len;
gchar *buf;
regex =
g_regex_new
("local:(?:///)?(?<filename>[^;]+);(?<address>[^;]+);(?<length>[^?]+)(?:[?]SchemaVersion=([^&]+))?",
(GRegexCompileFlags) 0, (GRegexMatchFlags) 0, &err);
if (!regex) {
goto error;
}
g_regex_match (regex, url, (GRegexMatchFlags) 0, &matchInfo);
filename = g_match_info_fetch_named (matchInfo, "filename");
addr_str = g_match_info_fetch_named (matchInfo, "address");
len_str = g_match_info_fetch_named (matchInfo, "length");
if (!filename || !addr_str || !len_str) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to parse local URL"), (NULL));
goto error;
}
addr = g_ascii_strtoull (addr_str, NULL, 16);
len = g_ascii_strtoull (len_str, NULL, 16);
buf = (gchar *) g_malloc (len);
GTL_GCReadPort (src->hDevPort, addr, buf, &len);
HANDLE_GTL_ERROR ("Failed to read XML from port");
if (g_str_has_suffix (filename, "zip")) {
gchar *zipfilepath;
unzFile uf;
unz_file_info64 fileinfo;
gchar xmlfilename[2048];
gchar *xml;
zipfilepath = g_build_filename (g_get_tmp_dir (), filename, NULL);
if (!g_file_set_contents (zipfilepath, buf, len, &err)) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to write zipped XML to %s", zipfilepath), (NULL));
goto error;
}
uf = unzOpen64 (zipfilepath);
if (!uf) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to open zipped XML %s", zipfilepath), (NULL));
goto error;
}
//ret = unzGetGlobalInfo64(uf, &gi);
ret =
unzGetCurrentFileInfo64 (uf, &fileinfo, xmlfilename,
sizeof (xmlfilename), NULL, 0, NULL, 0);
if (ret != UNZ_OK) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to query zip file %s", zipfilepath), (NULL));
goto error;
}
ret = unzOpenCurrentFile (uf);
if (ret != UNZ_OK) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to extract file %s", xmlfilename), (NULL));
goto error;
}
xml = (gchar *) g_malloc (fileinfo.uncompressed_size);
if (!xml) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to allocate memory to extract XML file"), (NULL));
goto error;
}
ret = unzReadCurrentFile (uf, xml, fileinfo.uncompressed_size);
if (ret != fileinfo.uncompressed_size) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to extract XML file %s", xmlfilename), (NULL));
goto error;
}
unzClose (uf);
g_free (zipfilepath);
zipfilepath = g_build_filename (g_get_tmp_dir (), xmlfilename, NULL);
g_file_set_contents (zipfilepath, xml, fileinfo.uncompressed_size,
&err);
g_free (zipfilepath);
g_free (xml);
//GZlibDecompressor *decompress;
//char *unzipped;
//gsize outbuf_size, bytes_read, bytes_written;
//GInputStream *zippedstream, *unzippedstream;
//decompress = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB);
////zippedstream = g_memory_input_stream_new_from_data(buf, len, g_free);
////unzippedstream = g_converter_input_stream_new (zippedstream, G_CONVERTER(decompress));
////g_input_stream_read_all (G_INPUT_STREAM(unzippedstream),
//// g_converter_output_stream
//outbuf_size = 10000000;
//unzipped = (gchar*) g_malloc(outbuf_size);
//g_converter_convert (G_CONVERTER (decompress), buf, len, unzipped, outbuf_size, G_CONVERTER_NO_FLAGS, &bytes_read, &bytes_written, &err);
//GST_DEBUG_OBJECT (src, unzipped);
}
g_free (filename);
g_free (addr_str);
g_free (len_str);
g_free (buf);
} else if (g_str_has_prefix (url, "http")) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("file url not supported yet"), (NULL));
goto error;
}
}
{
// TODO: use Genicam node map for this
guint32 val = 0;
size_t datasize = 4;
ret = GTL_GCReadPort (src->hDevPort, 0x30204, &val, &datasize);
HANDLE_GTL_ERROR ("Failed to get width");
width = GUINT32_FROM_BE (val);
ret = GTL_GCReadPort (src->hDevPort, 0x30224, &val, &datasize);
HANDLE_GTL_ERROR ("Failed to get height");
height = GUINT32_FROM_BE (val);
bpp = 8;
}
if (!gst_genicamsrc_prepare_buffers (src)) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY, ("Failed to prepare buffers"),
(NULL));
goto error;
}
{
ret =
GTL_GCRegisterEvent (src->hDS, EVENT_NEW_BUFFER, &src->hNewBufferEvent);
HANDLE_GTL_ERROR ("Failed to register New Buffer event");
}
ret =
GTL_DSStartAcquisition (src->hDS, ACQ_START_FLAGS_DEFAULT,
GENTL_INFINITE);
HANDLE_GTL_ERROR ("Failed to start stream acquisition");
{
// TODO: use Genicam node map for this
guint32 val;
size_t datasize;
/* set AcquisitionMode to Continuous */
val = GUINT32_TO_BE (2);
datasize = sizeof (val);
ret = GTL_GCWritePort (src->hDevPort, 0x40004, &val, &datasize);
HANDLE_GTL_ERROR ("Failed to start device acquisition");
/* send AcquisitionStart command */
val = GUINT32_TO_BE (1);
datasize = sizeof (val);
ret = GTL_GCWritePort (src->hDevPort, 0x40024, &val, &datasize);
HANDLE_GTL_ERROR ("Failed to start device acquisition");
}
/* create caps */
if (src->caps) {
gst_caps_unref (src->caps);
src->caps = NULL;
}
gst_video_info_init (&vinfo);
if (bpp <= 8) {
gst_video_info_set_format (&vinfo, GST_VIDEO_FORMAT_GRAY8, width, height);
src->caps = gst_video_info_to_caps (&vinfo);
} else if (bpp > 8 && bpp <= 16) {
GValue val = G_VALUE_INIT;
GstStructure *s;
if (G_BYTE_ORDER == G_LITTLE_ENDIAN) {
gst_video_info_set_format (&vinfo, GST_VIDEO_FORMAT_GRAY16_LE, width,
height);
} else if (G_BYTE_ORDER == G_BIG_ENDIAN) {
gst_video_info_set_format (&vinfo, GST_VIDEO_FORMAT_GRAY16_BE, width,
height);
}
src->caps = gst_video_info_to_caps (&vinfo);
/* set bpp, extra info for GRAY16 so elements can scale properly */
s = gst_caps_get_structure (src->caps, 0);
g_value_init (&val, G_TYPE_INT);
g_value_set_int (&val, bpp);
gst_structure_set_value (s, "bpp", &val);
g_value_unset (&val);
} else {
GST_ELEMENT_ERROR (src, STREAM, WRONG_TYPE,
("Unknown or unsupported bit depth (%d).", bpp), (NULL));
return FALSE;
}
src->height = vinfo.height;
src->gst_stride = GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 0);
GST_DEBUG_OBJECT (src, "starting acquisition");
//TODO: start acquisition engine
/* TODO: check timestamps on buffers vs start time */
src->acq_start_time =
gst_clock_get_time (gst_element_get_clock (GST_ELEMENT (src)));
return TRUE;
error:
if (src->hDS) {
GTL_DSClose (src->hDS);
src->hDS = NULL;
}
if (src->hDEV) {
GTL_DevClose (src->hDEV);
src->hDEV = NULL;
}
if (src->hIF) {
GTL_IFClose (src->hIF);
src->hIF = NULL;
}
if (src->hTL) {
GTL_TLClose (src->hTL);
src->hTL = NULL;
}
GTL_GCCloseLib ();
return FALSE;
}
void writeOmikujiFile(const gchar *fname, GList *comments, GList *fortunes)
{
OmikujiHeaderV0 header;
for (gint i = 0; i < 7; i++)
header.signature.signature[i] = OMIKUJI_SIGNATURE[i];
header.signature.version = OMIKUJI_VERSION;
guint32 offset = sizeof(header);
if (sort || uniqify)
fortunes = g_list_sort(fortunes, (GCompareFunc)stringCmp);
if (uniqify) {
/* Iterate from back to front and compare two entries,
removing the rearmost entry when stringCmp == 0. */
gboolean deleteChars = TRUE;
GList *current, *previous;
current = g_list_last(fortunes);
while (current != NULL) {
previous = g_list_previous(current);
if (previous != NULL) {
if (stringCmp(previous->data, current->data) == 0) {
stringDelete(current->data, &deleteChars);
fortunes = g_list_delete_link(fortunes, current);
}
}
current = previous;
}
}
if (comments != NULL) {
header.comment_table_offset = GUINT32_TO_BE(offset);
header.comment_count = GUINT32_TO_BE(g_list_length(comments));
offset += g_list_length(comments) * 8;
}
else {
header.comment_table_offset = 0;
header.comment_count = 0;
}
header.fortune_table_offset = GUINT32_TO_BE(offset);
header.fortune_count = GUINT32_TO_BE(g_list_length(fortunes));
offset += g_list_length(fortunes) * 8;
/*
* Rather than figure out all of the glib io channel stuff, I'm
* using stdio for now.
*/
FILE *out = fopen(fname, "w");
if (out) {
gint i, len;
guint32 oval;
fwrite(&header, sizeof(header), 1, out);
// Write comments offset table.
if (comments) {
len = g_list_length(comments);
for (i = 0; i < len; i++) {
GString *comment = g_list_nth_data(comments, i);
oval = GUINT32_TO_BE(offset);
fwrite(&oval, sizeof(oval), 1, out);
oval = GUINT32_TO_BE((comment->len - 1)); // we seem to be getting nul on the end
fwrite(&oval, sizeof(oval), 1, out);
offset += (comment->len - 1);
}
}
// Write fortunes offset table.
len = g_list_length(fortunes);
for (i = 0; i < len; i++) {
GString *fortune = g_list_nth_data(fortunes, i);
oval = GUINT32_TO_BE(offset);
fwrite(&oval, sizeof(oval), 1, out);
oval = GUINT32_TO_BE((fortune->len - 1));
fwrite(&oval, sizeof(oval), 1, out);
offset += (fortune->len - 1);
}
// Write the comments
if (comments) {
len = g_list_length(comments);
for (i = 0; i < len; i++) {
GString *comment = g_list_nth_data(comments, i);
fwrite(comment->str, sizeof(gchar), (comment->len - 1), out);
}
}
// Write the fortunes
len = g_list_length(fortunes);
for (i = 0; i < len; i++) {
GString *fortune = g_list_nth_data(fortunes, i);
fwrite(fortune->str, sizeof(gchar), (fortune->len - 1), out);
}
fclose(out);
}
}
GimpPDBStatusType
SaveICNS (const gchar *file_name,
gint32 image_ID)
{
// Horrible awful temporary hack
ResourceHeader icnsHeader;
ResourceHeader it32Header;
ResourceHeader t8mkHeader;
guchar *compData, *alphaData;
FILE *outfile;
guchar *pixels;
gint dataSize;
if (gimp_image_base_type (image_ID) != GIMP_RGB)
{
if (! gimp_image_convert_rgb (image_ID))
return GIMP_PDB_EXECUTION_ERROR;
}
gint *layers;
gint nlayers;
GimpPixelRgn region;
layers = gimp_image_get_layers (image_ID, &nlayers);
GimpDrawable *drawable = gimp_drawable_get (layers[0]);
pixels = g_new (guchar, 128*128*4);
gimp_pixel_rgn_init (®ion, drawable, 0, 0, 128, 128, TRUE, FALSE);
gimp_pixel_rgn_get_rect (®ion, pixels, 0, 0, 128, 128);
compData = icns_compress (128, 128, pixels, &dataSize);
alphaData = icns_get_alpha (128, 128, pixels);
it32Header.type = GUINT32_TO_BE ('it32');
it32Header.size = GUINT32_TO_BE (sizeof (ResourceHeader) + dataSize);
t8mkHeader.type = GUINT32_TO_BE ('t8mk');
t8mkHeader.size = GUINT32_TO_BE (sizeof (ResourceHeader) + 128*128);
icnsHeader.type = GUINT32_TO_BE ('icns');
icnsHeader.size = dataSize + 128*128 + 3 * sizeof (ResourceHeader);
outfile = fopen (file_name, "wb");
if (outfile)
{
fwrite (&icnsHeader, 1, sizeof (ResourceHeader), outfile);
fwrite (&it32Header, 1, sizeof (ResourceHeader), outfile);
fwrite (compData, 1, dataSize, outfile);
fwrite (&t8mkHeader, 1, sizeof (ResourceHeader), outfile);
fwrite (alphaData, 1, 128*128, outfile);
fclose (outfile);
}
else
{
g_warning ("SaveICNS: couldn't open output file");
}
g_free (pixels);
g_free (compData);
g_free (alphaData);
return GIMP_PDB_SUCCESS;
}
void
msn_write32be(char *buf, guint32 data)
{
data = GUINT32_TO_BE(data);
memcpy(buf, &data, sizeof(data));
}
void wr_long(uint8_t *p, uint32_t d)
{
uint32_t *p32 = (uint32_t *)p;
*p32 = GUINT32_TO_BE(d);
}
/* This function gets the X Display and global info about it. Everything is
stored in our object and will be cleaned when the object is disposed. Note
here that caps for supported format are generated without any window or
image creation */
GstXContext *
ximageutil_xcontext_get (GstElement * parent, const gchar * display_name)
{
GstXContext *xcontext = NULL;
XPixmapFormatValues *px_formats = NULL;
gint nb_formats = 0, i;
xcontext = g_new0 (GstXContext, 1);
xcontext->disp = XOpenDisplay (display_name);
GST_DEBUG_OBJECT (parent, "opened display %p", xcontext->disp);
if (!xcontext->disp) {
g_free (xcontext);
return NULL;
}
xcontext->screen = DefaultScreenOfDisplay (xcontext->disp);
xcontext->screen_num = DefaultScreen (xcontext->disp);
xcontext->visual = DefaultVisual (xcontext->disp, xcontext->screen_num);
xcontext->root = DefaultRootWindow (xcontext->disp);
xcontext->white = XWhitePixel (xcontext->disp, xcontext->screen_num);
xcontext->black = XBlackPixel (xcontext->disp, xcontext->screen_num);
xcontext->depth = DefaultDepthOfScreen (xcontext->screen);
xcontext->width = DisplayWidth (xcontext->disp, xcontext->screen_num);
xcontext->height = DisplayHeight (xcontext->disp, xcontext->screen_num);
xcontext->widthmm = DisplayWidthMM (xcontext->disp, xcontext->screen_num);
xcontext->heightmm = DisplayHeightMM (xcontext->disp, xcontext->screen_num);
xcontext->caps = NULL;
GST_DEBUG_OBJECT (parent, "X reports %dx%d pixels and %d mm x %d mm",
xcontext->width, xcontext->height, xcontext->widthmm, xcontext->heightmm);
ximageutil_calculate_pixel_aspect_ratio (xcontext);
/* We get supported pixmap formats at supported depth */
px_formats = XListPixmapFormats (xcontext->disp, &nb_formats);
if (!px_formats) {
XCloseDisplay (xcontext->disp);
g_free (xcontext);
return NULL;
}
/* We get bpp value corresponding to our running depth */
for (i = 0; i < nb_formats; i++) {
if (px_formats[i].depth == xcontext->depth)
xcontext->bpp = px_formats[i].bits_per_pixel;
}
XFree (px_formats);
xcontext->endianness =
(ImageByteOrder (xcontext->disp) ==
LSBFirst) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN;
#ifdef HAVE_XSHM
/* Search for XShm extension support */
if (XShmQueryExtension (xcontext->disp) &&
ximageutil_check_xshm_calls (xcontext)) {
xcontext->use_xshm = TRUE;
GST_DEBUG ("ximageutil is using XShm extension");
} else {
xcontext->use_xshm = FALSE;
GST_DEBUG ("ximageutil is not using XShm extension");
}
#endif /* HAVE_XSHM */
/* our caps system handles 24/32bpp RGB as big-endian. */
if ((xcontext->bpp == 24 || xcontext->bpp == 32) &&
xcontext->endianness == G_LITTLE_ENDIAN) {
xcontext->endianness = G_BIG_ENDIAN;
xcontext->r_mask_output = GUINT32_TO_BE (xcontext->visual->red_mask);
xcontext->g_mask_output = GUINT32_TO_BE (xcontext->visual->green_mask);
xcontext->b_mask_output = GUINT32_TO_BE (xcontext->visual->blue_mask);
if (xcontext->bpp == 24) {
xcontext->r_mask_output >>= 8;
xcontext->g_mask_output >>= 8;
xcontext->b_mask_output >>= 8;
}
char *
msn_message_gen_payload(MsnMessage *msg, size_t *ret_size)
{
GList *l;
char *n, *base, *end;
int len;
size_t body_len = 0;
const void *body;
g_return_val_if_fail(msg != NULL, NULL);
len = MSN_BUF_LEN;
base = n = end = g_malloc(len + 1);
end += len;
/* Standard header. */
if (msg->charset == NULL)
{
g_snprintf(n, len,
"MIME-Version: 1.0\r\n"
"Content-Type: %s\r\n",
msg->content_type);
}
else
{
g_snprintf(n, len,
"MIME-Version: 1.0\r\n"
"Content-Type: %s; charset=%s\r\n",
msg->content_type, msg->charset);
}
n += strlen(n);
for (l = msg->attr_list; l != NULL; l = l->next)
{
const char *key;
const char *value;
key = l->data;
value = msn_message_get_attr(msg, key);
g_snprintf(n, end - n, "%s: %s\r\n", key, value);
n += strlen(n);
}
n += g_strlcpy(n, "\r\n", end - n);
body = msn_message_get_bin_data(msg, &body_len);
if (msg->msnslp_message)
{
MsnSlpHeader header;
MsnSlpFooter footer;
header.session_id = GUINT32_TO_LE(msg->msnslp_header.session_id);
header.id = GUINT32_TO_LE(msg->msnslp_header.id);
header.offset = GUINT64_TO_LE(msg->msnslp_header.offset);
header.total_size = GUINT64_TO_LE(msg->msnslp_header.total_size);
header.length = GUINT32_TO_LE(msg->msnslp_header.length);
header.flags = GUINT32_TO_LE(msg->msnslp_header.flags);
header.ack_id = GUINT32_TO_LE(msg->msnslp_header.ack_id);
header.ack_sub_id = GUINT32_TO_LE(msg->msnslp_header.ack_sub_id);
header.ack_size = GUINT64_TO_LE(msg->msnslp_header.ack_size);
memcpy(n, &header, 48);
n += 48;
if (body != NULL)
{
memcpy(n, body, body_len);
n += body_len;
}
footer.value = GUINT32_TO_BE(msg->msnslp_footer.value);
memcpy(n, &footer, 4);
n += 4;
}
else
{
if (body != NULL)
{
memcpy(n, body, body_len);
n += body_len;
}
}
if (ret_size != NULL)
{
*ret_size = n - base;
if (*ret_size > 1664)
*ret_size = 1664;
}
return base;
}
