static int sym_find_handle_89(const char *dirname, const char *filename)
{
uint32_t fa, va;
uint16_t fs, vs;
int nfolders, nvars;
int i, j;
int handle = 0x08;
if(tihw.calc_type == TI92)
return -1;
// handle: names and handles of all folders (including "main")
if(strcmp(img_infos.version, "2.00") >= 0)
handle = get_folder_list_handle(); // AMS2 (dynamic)
else
handle = 0x08; // AMS1 (static)
if(handle == -1)
return 0;
else
heap_get_block_addr_and_size(handle, &fa, &fs);
// skip maximum number of folders before handle #$B needs to be resized
// and actual number of folders
nfolders = mem_rd_word(fa+2);
fa += 4;
// now, we read a list of SYM_ENTRY structs (list of folders)
for(i=0; i<nfolders; i++)
{
TI89_SYM_ENTRY se;
// read struct
memcpy(&se, ti68k_get_real_address(fa + i * sizeof(TI89_SYM_ENTRY)), sizeof(TI89_SYM_ENTRY));
se.handle = GUINT16_FROM_BE(se.handle);
if (strncmp (se.name, dirname, 8)) continue;
// handle xxxx: names and handles of all variables
heap_get_block_addr_and_size(se.handle, &va, &vs);
// skip max num and actual num of vars
nvars = mem_rd_word(va+2);
va += 4;
for(j=0; j<nvars; j++)
{
// read struct
memcpy(&se, ti68k_get_real_address(va + j * sizeof(TI89_SYM_ENTRY)), sizeof(TI89_SYM_ENTRY));
se.handle = GUINT16_FROM_BE(se.handle);
// add node
if (strncmp (se.name, filename, 8)) continue;
return se.handle;
}
}
return 0;
}
/**
* fwupd_guid_to_string:
* @guid: a #fwupd_guid_t to read
* @flags: some %FwupdGuidFlags, e.g. %FWUPD_GUID_FLAG_MIXED_ENDIAN
*
* Returns a text GUID of mixed or BE endian for a packed buffer.
*
* Returns: A new GUID
*
* Since: 1.2.5
**/
gchar *
fwupd_guid_to_string (const fwupd_guid_t *guid, FwupdGuidFlags flags)
{
fwupd_guid_native_t gnat;
g_return_val_if_fail (guid != NULL, NULL);
/* copy to avoid issues with aligning */
memcpy (&gnat, guid, sizeof(gnat));
/* mixed is bizaar, but specified as the DCE encoding */
if (flags & FWUPD_GUID_FLAG_MIXED_ENDIAN) {
return g_strdup_printf ("%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
GUINT32_FROM_LE(gnat.a),
GUINT16_FROM_LE(gnat.b),
GUINT16_FROM_LE(gnat.c),
GUINT16_FROM_BE(gnat.d),
gnat.e[0], gnat.e[1],
gnat.e[2], gnat.e[3],
gnat.e[4], gnat.e[5]);
}
return g_strdup_printf ("%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
GUINT32_FROM_BE(gnat.a),
GUINT16_FROM_BE(gnat.b),
GUINT16_FROM_BE(gnat.c),
GUINT16_FROM_BE(gnat.d),
gnat.e[0], gnat.e[1],
gnat.e[2], gnat.e[3],
gnat.e[4], gnat.e[5]);
}
// tested: OK.
static int parse_vat_92(GNode *node_top)
{
uint32_t fa, va, pa;
uint16_t fs, vs, ps;
int nfolders, nvars;
int i, j;
VatSymEntry *vse;
GNode *node_fol, *node_var;
if(tihw.calc_type != TI92)
return -1;
// handle 000B: names and handles of all folders (including "main")
heap_get_block_addr_and_size(0xb, &fa, &fs);
// skip maximum number of folders before handle #$B needs to be resized
// and actual number of folders
nfolders = mem_rd_word(fa+2);
fa += 4;
// now, we read a list of SYM_ENTRY structs (list of folders)
for(i=0; i<nfolders; i++)
{
TI92_SYM_ENTRY se;
// read struct
memcpy(&se, ti68k_get_real_address(fa + i * sizeof(TI92_SYM_ENTRY)), sizeof(TI92_SYM_ENTRY));
se.handle = GUINT16_FROM_BE(se.handle);
// add node
vse = g_malloc0(sizeof(VatSymEntry));
strcpy(vse->name, se.name); vse->handle = se.handle;
g_node_append(node_top, node_fol = g_node_new(vse));
// handle xxxx: names and handles of all variables
heap_get_block_addr_and_size(se.handle, &va, &vs);
// skip max num and actual num of vars
nvars = mem_rd_word(va+2);
va += 4;
for(j=0; j<nvars; j++)
{
// read struct
memcpy(&se, ti68k_get_real_address(va + j * sizeof(TI92_SYM_ENTRY)), sizeof(TI92_SYM_ENTRY));
se.handle = GUINT16_FROM_BE(se.handle);
// add node
vse = g_malloc0(sizeof(VatSymEntry));
strcpy(vse->name, se.name); vse->handle = se.handle;
g_node_append(node_fol, node_var = g_node_new(vse));
// handle: variable content
heap_get_block_addr_and_size(se.handle, &pa, &ps);
}
}
return 0;
}
static gint
read_header_block (PSDimage *img_a,
FILE *f,
GError **error)
{
guint16 version;
gchar sig[4];
gchar buf[6];
if (fread (sig, 4, 1, f) < 1
|| fread (&version, 2, 1, f) < 1
|| fread (buf, 6, 1, f) < 1
|| fread (&img_a->channels, 2, 1, f) < 1
|| fread (&img_a->rows, 4, 1, f) < 1
|| fread (&img_a->columns, 4, 1, f) < 1
|| fread (&img_a->bps, 2, 1, f) < 1
|| fread (&img_a->color_mode, 2, 1, f) < 1)
{
psd_set_error (feof (f), errno, error);
return -1;
}
version = GUINT16_FROM_BE (version);
img_a->channels = GUINT16_FROM_BE (img_a->channels);
img_a->rows = GUINT32_FROM_BE (img_a->rows);
img_a->columns = GUINT32_FROM_BE (img_a->columns);
img_a->bps = GUINT16_FROM_BE (img_a->bps);
img_a->color_mode = GUINT16_FROM_BE (img_a->color_mode);
IFDBG(1) g_debug ("\n\n\tSig: %.4s\n\tVer: %d\n\tChannels: "
"%d\n\tSize: %dx%d\n\tBPS: %d\n\tMode: %d\n",
sig, version, img_a->channels,
img_a->columns, img_a->rows,
img_a->bps, img_a->color_mode);
if (memcmp (sig, "8BPS", 4) != 0)
return -1;
if (version != 1)
return -1;
if (img_a->channels > MAX_CHANNELS)
return -1;
if (img_a->rows < 1 || img_a->rows > GIMP_MAX_IMAGE_SIZE)
return -1;
if (img_a->columns < 1 || img_a->columns > GIMP_MAX_IMAGE_SIZE)
return -1;
return 0;
}
static int sym_find_handle_92(const char *dirname, const char *filename)
{
uint32_t fa, va;
uint16_t fs, vs;
int nfolders, nvars;
int i, j;
if(tihw.calc_type != TI92)
return 0;
// handle 000B: names and handles of all folders (including "main")
heap_get_block_addr_and_size(0xb, &fa, &fs);
// skip maximum number of folders before handle #$B needs to be resized
// and actual number of folders
nfolders = mem_rd_word(fa+2);
fa += 4;
// now, we read a list of SYM_ENTRY structs (list of folders)
for(i=0; i<nfolders; i++)
{
TI92_SYM_ENTRY se;
// read struct
memcpy(&se, ti68k_get_real_address(fa + i * sizeof(TI92_SYM_ENTRY)), sizeof(TI92_SYM_ENTRY));
se.handle = GUINT16_FROM_BE(se.handle);
if (strncmp (se.name, dirname, 8)) continue;
// handle xxxx: names and handles of all variables
heap_get_block_addr_and_size(se.handle, &va, &vs);
// skip max num and actual num of vars
nvars = mem_rd_word(va+2);
va += 4;
for(j=0; j<nvars; j++)
{
// read struct
memcpy(&se, ti68k_get_real_address(va + j * sizeof(TI92_SYM_ENTRY)), sizeof(TI92_SYM_ENTRY));
se.handle = GUINT16_FROM_BE(se.handle);
// add node
if (strncmp (se.name, filename, 8)) continue;
return se.handle;
}
}
return 0;
}
bool
SMFReader::open(const string& filename) throw (logic_error, UnsupportedTime)
{
if (_fd)
throw logic_error("Attempt to start new read while write in progress.");
cout << "Opening SMF file " << filename << " for reading." << endl;
_fd = fopen(filename.c_str(), "r+");
if (_fd) {
// Read type (bytes 8..9)
fseek(_fd, 0, SEEK_SET);
char mthd[5];
mthd[4] = '\0';
fread(mthd, 1, 4, _fd);
if (strcmp(mthd, "MThd")) {
cerr << filename << " is not an SMF file, aborting." << endl;
fclose(_fd);
_fd = NULL;
return false;
}
// Read type (bytes 8..9)
fseek(_fd, 8, SEEK_SET);
uint16_t type_be = 0;
fread(&type_be, 2, 1, _fd);
_type = GUINT16_FROM_BE(type_be);
// Read number of tracks (bytes 10..11)
uint16_t num_tracks_be = 0;
fread(&num_tracks_be, 2, 1, _fd);
_num_tracks = GUINT16_FROM_BE(num_tracks_be);
// Read PPQN (bytes 12..13)
uint16_t ppqn_be = 0;
fread(&ppqn_be, 2, 1, _fd);
_ppqn = GUINT16_FROM_BE(ppqn_be);
// TODO: Absolute (SMPTE seconds) time support
if ((_ppqn & 0x8000) != 0)
throw UnsupportedTime();
seek_to_track(1);
return true;
} else {
return false;
}
}
static void
write_command_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
GOutputStream *output = G_OUTPUT_STREAM (object);
RequestData *req_data = user_data;
GVfsAfpConnection *afp_conn = req_data->conn;
GVfsAfpConnectionPrivate *priv = afp_conn->priv;
HANDLE_RES ();
if (priv->write_dsi_header.command == DSI_WRITE &&
req_data->command->buf)
{
write_all_async (output, req_data->command->buf, req_data->command->buf_size,
0, NULL, write_buf_cb, req_data);
return;
}
g_hash_table_insert (priv->request_hash,
GUINT_TO_POINTER ((guint)GUINT16_FROM_BE (priv->write_dsi_header.requestID)),
req_data);
g_mutex_lock (&priv->mutex);
send_request_unlocked (afp_conn);
g_mutex_unlock (&priv->mutex);
}
static void
write_command_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
GOutputStream *output = G_OUTPUT_STREAM (object);
GVfsAfpConnection *afp_conn = G_VFS_AFP_CONNECTION (user_data);
GVfsAfpConnectionPrivate *priv = afp_conn->priv;
RequestData *req_data;
req_data = g_queue_peek_head (priv->request_queue);
HANDLE_RES ();
if (priv->write_dsi_header.command == DSI_WRITE &&
req_data->command->buf)
{
write_all_async (output, req_data->command->buf, req_data->command->buf_size,
0, NULL, write_buf_cb, afp_conn);
return;
}
g_hash_table_insert (priv->request_hash,
GUINT_TO_POINTER ((guint)GUINT16_FROM_BE (priv->write_dsi_header.requestID)),
req_data);
g_queue_pop_head (priv->request_queue);
send_request (afp_conn);
}
guint16
msn_read16be(const char *buf)
{
guint16 val;
memcpy(&val, buf, sizeof(val));
return GUINT16_FROM_BE(val);
}
static int convert_stereo_to_mono_u16be(struct xmms_convert_buffers* buf, void **data, int length)
{
guint16 *output = *data, *input = *data;
int i;
for (i = 0; i < length / 4; i++)
{
guint32 tmp;
guint16 stmp;
tmp = GUINT16_FROM_BE(*input);
input++;
tmp += GUINT16_FROM_BE(*input);
input++;
stmp = tmp / 2;
*output++ = GUINT16_TO_BE(stmp);
}
return length / 2;
}
/**
* Reads an unsigned 16-bit Big Endian value from the stream into native endian format.
*
* @param value Pointer to the variable to read the value into.
* @param stream A #VFSFile object representing the stream.
* @return TRUE if read was succesful, FALSE if there was an error.
*/
EXPORT bool_t vfs_fget_be16(uint16_t *value, VFSFile *stream)
{
uint16_t tmp;
if (vfs_fread(&tmp, sizeof(tmp), 1, stream) != 1)
return FALSE;
*value = GUINT16_FROM_BE(tmp);
return TRUE;
}
static bool_t read_frame (VFSFile * handle, int max_size, int version,
bool_t syncsafe, int * frame_size, char * key, char * * data, int * size)
{
ID3v2FrameHeader header;
int skip = 0;
if ((max_size -= sizeof (ID3v2FrameHeader)) < 0)
return FALSE;
if (vfs_fread (& header, 1, sizeof (ID3v2FrameHeader), handle) != sizeof
(ID3v2FrameHeader))
return FALSE;
if (! header.key[0]) /* padding */
return FALSE;
header.size = (version == 3) ? GUINT32_FROM_BE (header.size) : unsyncsafe32
(GUINT32_FROM_BE (header.size));
header.flags = GUINT16_FROM_BE (header.flags);
if (header.size > max_size || header.size == 0)
return FALSE;
TAGDBG ("Found frame:\n");
TAGDBG (" key = %.4s\n", header.key);
TAGDBG (" size = %d\n", (int) header.size);
TAGDBG (" flags = %x\n", (int) header.flags);
* frame_size = sizeof (ID3v2FrameHeader) + header.size;
g_strlcpy (key, header.key, 5);
if (header.flags & (ID3_FRAME_COMPRESSED | ID3_FRAME_ENCRYPTED))
{
TAGDBG ("Hit compressed/encrypted frame %s.\n", key);
return FALSE;
}
if (header.flags & ID3_FRAME_HAS_GROUP)
skip ++;
if (header.flags & ID3_FRAME_HAS_LENGTH)
skip += 4;
if ((skip > 0 && vfs_fseek (handle, skip, SEEK_CUR)) || skip >= header.size)
return FALSE;
* size = header.size - skip;
* data = g_malloc (* size);
if (vfs_fread (* data, 1, * size, handle) != * size)
return FALSE;
if (syncsafe || (header.flags & ID3_FRAME_SYNCSAFE))
* size = unsyncsafe (* data, * size);
TAGDBG ("Data size = %d.\n", * size);
return TRUE;
}
static void
read_dsi_header_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
GInputStream *input = G_INPUT_STREAM (object);
GVfsAfpConnection *afp_conn = G_VFS_AFP_CONNECTION (user_data);
GVfsAfpConnectionPrivate *priv = afp_conn->priv;
gboolean result;
GError *err = NULL;
DSIHeader *dsi_header;
if (g_atomic_int_get (&priv->atomic_state) == STATE_PENDING_CLOSE)
{
if (!priv->send_loop_running)
close_connection (afp_conn);
return;
}
result = read_all_finish (input, res, NULL, &err);
if (!result)
{
g_warning ("FAIL!!! \"%s\"\n", err->message);
g_error_free (err);
}
dsi_header = &priv->read_dsi_header;
dsi_header->requestID = GUINT16_FROM_BE (dsi_header->requestID);
dsi_header->errorCode = GUINT32_FROM_BE (dsi_header->errorCode);
dsi_header->totalDataLength = GUINT32_FROM_BE (dsi_header->totalDataLength);
if (dsi_header->totalDataLength > 0)
{
RequestData *req_data;
req_data = g_hash_table_lookup (priv->request_hash,
GUINT_TO_POINTER ((guint)dsi_header->requestID));
if (req_data && req_data->reply_buf)
{
priv->reply_buf = req_data->reply_buf;
priv->free_reply_buf = FALSE;
}
else
{
priv->reply_buf = g_malloc (dsi_header->totalDataLength);
priv->free_reply_buf = TRUE;
}
read_all_async (input, priv->reply_buf, dsi_header->totalDataLength,
0, priv->read_cancellable, read_data_cb, afp_conn);
return;
}
dispatch_reply (afp_conn);
read_reply (afp_conn);
}
static void
ppm_load_read_image(FILE *fp,
pnm_struct *img)
{
guint i;
if (img->type == PIXMAP_RAW || img->type == PIXMAP_RAW_GRAY)
{
if (fread (img->data, img->bpc, img->numsamples, fp) == 0)
return;
/* Fix endianness if necessary */
if (img->bpc > 1)
{
gushort *ptr = (gushort *) img->data;
for (i=0; i < img->numsamples; i++)
{
*ptr = GUINT16_FROM_BE (*ptr);
ptr++;
}
}
}
else
{
/* Plain PPM or PGM format */
if (img->bpc == sizeof (guchar))
{
guchar *ptr = img->data;
for (i = 0; i < img->numsamples; i++)
{
guint sample;
if (!fscanf (fp, " %u", &sample))
sample = 0;
*ptr++ = sample;
}
}
else if (img->bpc == sizeof (gushort))
{
gushort *ptr = (gushort *) img->data;
for (i = 0; i < img->numsamples; i++)
{
guint sample;
if (!fscanf (fp, " %u", &sample))
sample = 0;
*ptr++ = sample;
}
}
else
{
g_warning ("%s: Programmer stupidity error", G_STRLOC);
}
}
}
/**
* Read and parse a "SND" chunk inside "PROP".
*/
static bool
dsdiff_read_prop_snd(struct decoder *decoder, struct input_stream *is,
struct dsdiff_metadata *metadata,
goffset end_offset)
{
struct dsdiff_chunk_header header;
while ((goffset)(is->offset + sizeof(header)) <= end_offset) {
if (!dsdiff_read_chunk_header(decoder, is, &header))
return false;
goffset chunk_end_offset =
is->offset + dsdiff_chunk_size(&header);
if (chunk_end_offset > end_offset)
return false;
if (dsdiff_id_equals(&header.id, "FS ")) {
uint32_t sample_rate;
if (!dsdiff_read_payload(decoder, is, &header,
&sample_rate,
sizeof(sample_rate)))
return false;
metadata->sample_rate = GUINT32_FROM_BE(sample_rate);
} else if (dsdiff_id_equals(&header.id, "CHNL")) {
uint16_t channels;
if (dsdiff_chunk_size(&header) < sizeof(channels) ||
!dsdiff_read(decoder, is,
&channels, sizeof(channels)) ||
!dsdiff_skip_to(decoder, is, chunk_end_offset))
return false;
metadata->channels = GUINT16_FROM_BE(channels);
} else if (dsdiff_id_equals(&header.id, "CMPR")) {
struct dsdiff_id type;
if (dsdiff_chunk_size(&header) < sizeof(type) ||
!dsdiff_read(decoder, is,
&type, sizeof(type)) ||
!dsdiff_skip_to(decoder, is, chunk_end_offset))
return false;
if (!dsdiff_id_equals(&type, "DSD "))
/* only uncompressed DSD audio data
is implemented */
return false;
} else {
/* ignore unknown chunk */
if (!dsdiff_skip_to(decoder, is, chunk_end_offset))
return false;
}
}
return is->offset == end_offset;
}
gboolean falcon_object_load(falcon_object_t *object, void *userdata)
{
int fd = GPOINTER_TO_INT(userdata);
guint16 len = 0;
g_return_val_if_fail(object, FALSE);
if (read(fd, &len, 2) == -1) {
g_critical(_("Failed to read the length of object: %s"),
g_strerror(errno));
return FALSE;
}
len = GUINT16_FROM_BE(len);
object->name = g_new0(gchar, len + 1);
if (read(fd, object->name, len) == -1) {
g_critical(_("Failed to read object name: %s"), g_strerror(errno));
g_free(object->name);
return FALSE;
}
if (read(fd, &(object->size), 8) == -1) {
g_critical(_("Failed to read object size \"%s\": %s"), object->name,
g_strerror(errno));
g_free(object->name);
return FALSE;
}
object->size = GUINT64_FROM_BE(object->size);
if (read(fd, &(object->time), 8) == -1) {
g_critical(_("Failed to read object time \"%s\": %s"), object->name,
g_strerror(errno));
g_free(object->name);
return FALSE;
}
object->time = GUINT64_FROM_BE(object->time);
if (read(fd, &(object->mode), 4) == -1) {
g_critical(_("Failed to read object mode \"%s\": %s"), object->name,
g_strerror(errno));
g_free(object->name);
return FALSE;
}
object->mode = GUINT32_FROM_BE(object->mode);
if (read(fd, &(object->watch), 1) == -1) {
g_critical(_("Failed to read object watch \"%s\": %s"), object->name,
g_strerror(errno));
g_free(object->name);
return FALSE;
}
return TRUE;
}
static gboolean
read_reply_sync (GInputStream *input,
DSIHeader *dsi_header,
char **data,
GCancellable *cancellable,
GError **error)
{
gboolean res;
gsize read_count, bytes_read;
g_assert (dsi_header != NULL);
read_count = sizeof (DSIHeader);
res = g_input_stream_read_all (input, dsi_header, read_count, &bytes_read,
cancellable, error);
if (!res)
return FALSE;
if (bytes_read < read_count)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Connection unexpectedly went down"));
return FALSE;
}
dsi_header->requestID = GUINT16_FROM_BE (dsi_header->requestID);
dsi_header->errorCode = GUINT32_FROM_BE (dsi_header->errorCode);
dsi_header->totalDataLength = GUINT32_FROM_BE (dsi_header->totalDataLength);
if (dsi_header->totalDataLength == 0)
{
*data = NULL;
return TRUE;
}
*data = g_malloc (dsi_header->totalDataLength);
read_count = dsi_header->totalDataLength;
res = g_input_stream_read_all (input, *data, read_count, &bytes_read, cancellable, error);
if (!res)
{
g_free (*data);
return FALSE;
}
if (bytes_read < read_count)
{
g_free (*data);
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Got EOS"));
return FALSE;
}
return TRUE;
}
gboolean
g_vfs_afp_reply_read_uint16 (GVfsAfpReply *reply, guint16 *val)
{
if ((reply->len - reply->pos) < 2)
return FALSE;
if (val)
*val = GUINT16_FROM_BE (*((guint16 *)(reply->data + reply->pos)));
reply->pos += 2;
return TRUE;
}
static void convert_buffer(gpointer buffer, gint length)
{
gint i;
if (afmt == FMT_S8)
{
guint8 *ptr1 = buffer;
gint8 *ptr2 = buffer;
for (i = 0; i < length; i++)
*(ptr1++) = *(ptr2++) ^ 128;
}
if (afmt == FMT_S16_BE)
{
gint16 *ptr = buffer;
for (i = 0; i < length >> 1; i++, ptr++)
*ptr = GUINT16_SWAP_LE_BE(*ptr);
}
if (afmt == FMT_S16_NE)
{
gint16 *ptr = buffer;
for (i = 0; i < length >> 1; i++, ptr++)
*ptr = GINT16_TO_LE(*ptr);
}
if (afmt == FMT_U16_BE)
{
gint16 *ptr1 = buffer;
guint16 *ptr2 = buffer;
for (i = 0; i < length >> 1; i++, ptr2++)
*(ptr1++) = GINT16_TO_LE(GUINT16_FROM_BE(*ptr2) ^ 32768);
}
if (afmt == FMT_U16_LE)
{
gint16 *ptr1 = buffer;
guint16 *ptr2 = buffer;
for (i = 0; i < length >> 1; i++, ptr2++)
*(ptr1++) = GINT16_TO_LE(GUINT16_FROM_LE(*ptr2) ^ 32768);
}
if (afmt == FMT_U16_NE)
{
gint16 *ptr1 = buffer;
guint16 *ptr2 = buffer;
for (i = 0; i < length >> 1; i++, ptr2++)
*(ptr1++) = GINT16_TO_LE((*ptr2) ^ 32768);
}
}
static int64_t read_uint16(FILE *f, uint16_t endian) {
uint16_t result;
if (fread(&result, sizeof result, 1, f) != 1) {
return -1;
}
switch (endian) {
case TIFF_BIGENDIAN:
return GUINT16_FROM_BE(result);
case TIFF_LITTLEENDIAN:
return GUINT16_FROM_LE(result);
default:
g_return_val_if_reached(-1);
}
}
static gboolean
fetch_card16 (XSettingsBuffer *buffer,
CARD16 *result)
{
CARD16 x;
return_if_fail_bytes (buffer, 2);
x = *(CARD16 *)buffer->pos;
buffer->pos += 2;
if (buffer->byte_order == MSBFirst)
*result = GUINT16_FROM_BE (x);
else
*result = GUINT16_FROM_LE (x);
return TRUE;
}
/* The way the checksum is constructed (header->checksum is the complement),
* the return value is expected to be zero */
static guint
igor_checksum(gconstpointer buffer, gsize size, gboolean lsb)
{
const guint16 *p = (const guint16*)buffer;
guint i, sum;
/* This ignores the last byte should the size be odd, IGOR seems to do
* the same. */
if (lsb) {
for (sum = 0, i = 0; i < size/2; ++i)
sum += GUINT16_FROM_LE(p[i]);
}
else {
for (sum = 0, i = 0; i < size/2; ++i)
sum += GUINT16_FROM_BE(p[i]);
}
return sum & 0xffff;
}
static void *read_tiff_tag_2(FILE *f,
int64_t count, int64_t offset,
uint8_t value[], uint16_t endian) {
uint16_t *result = g_try_new(uint16_t, count);
if (result == NULL) {
goto FAIL;
}
if (!read_tiff_tag(f, count * sizeof *result, result, offset, value)) {
goto FAIL;
}
// swap?
for (int64_t i = 0; i < count; i++) {
if (endian == TIFF_BIGENDIAN) {
result[i] = GUINT16_FROM_BE(result[i]);
} else {
result[i] = GUINT16_FROM_LE(result[i]);
}
}
/*
g_debug(" count %" PRId64, count);
for (int i = 0; i < count; i++) {
if (i > 50) {
g_debug(" ...");
break;
}
g_debug(" %u", result[i]);
}
g_debug(" ");
*/
return result;
FAIL:
g_free(result);
return NULL;
}
/**
* qmi_utils_read_guint16_from_buffer:
* @buffer: a buffer with raw binary data.
* @buffer_size: size of @buffer.
* @endian: endianness of firmware value; swapped to host byte order if necessary
* @out: return location for the read variable.
*
* Reads an unsigned 16-bit integer from the buffer. The number in the buffer is
* expected to be given in the byte order specificed by @endian, and this method
* takes care of converting the read value to the proper host endianness.
*
* The user needs to make sure that at least 2 bytes are available
* in the buffer.
*
* Also note that both @buffer and @buffer_size get updated after the 2 bytes
* read.
*/
void
qmi_utils_read_guint16_from_buffer (const guint8 **buffer,
guint16 *buffer_size,
QmiEndian endian,
guint16 *out)
{
g_assert (out != NULL);
g_assert (buffer != NULL);
g_assert (buffer_size != NULL);
g_assert (*buffer_size >= 2);
memcpy (out, &((*buffer)[0]), 2);
if (endian == QMI_ENDIAN_BIG)
*out = GUINT16_FROM_BE (*out);
else
*out = GUINT16_FROM_LE (*out);
print_read_bytes_trace ("guint16", &(*buffer)[0], out, 2);
*buffer = &((*buffer)[2]);
*buffer_size = (*buffer_size) - 2;
}
uint16_t rd_word(uint8_t *p)
{
uint16_t *p16 = (uint16_t *)p;
return GUINT16_FROM_BE(*p16);
}
static int convert_stereo_to_mono(void **data, int length, int fmt)
{
int i;
switch (fmt)
{
case AFMT_U8:
{
guint8 *output = *data, *input = *data;
for (i = 0; i < length / 2; i++)
{
guint16 tmp;
tmp = *input++;
tmp += *input++;
*output++ = tmp / 2;
}
}
break;
case AFMT_S8:
{
gint8 *output = *data, *input = *data;
for (i = 0; i < length / 2; i++)
{
gint16 tmp;
tmp = *input++;
tmp += *input++;
*output++ = tmp / 2;
}
}
break;
case AFMT_U16_LE:
{
guint16 *output = *data, *input = *data;
for (i = 0; i < length / 4; i++)
{
guint32 tmp;
guint16 stmp;
tmp = GUINT16_FROM_LE(*input);
input++;
tmp += GUINT16_FROM_LE(*input);
input++;
stmp = tmp / 2;
*output++ = GUINT16_TO_LE(stmp);
}
}
break;
case AFMT_U16_BE:
{
guint16 *output = *data, *input = *data;
for (i = 0; i < length / 4; i++)
{
guint32 tmp;
guint16 stmp;
tmp = GUINT16_FROM_BE(*input);
input++;
tmp += GUINT16_FROM_BE(*input);
input++;
stmp = tmp / 2;
*output++ = GUINT16_TO_BE(stmp);
}
}
break;
case AFMT_S16_LE:
{
gint16 *output = *data, *input = *data;
for (i = 0; i < length / 4; i++)
{
gint32 tmp;
gint16 stmp;
tmp = GINT16_FROM_LE(*input);
input++;
tmp += GINT16_FROM_LE(*input);
input++;
stmp = tmp / 2;
*output++ = GINT16_TO_LE(stmp);
}
}
break;
case AFMT_S16_BE:
{
gint16 *output = *data, *input = *data;
for (i = 0; i < length / 4; i++)
{
gint32 tmp;
gint16 stmp;
tmp = GINT16_FROM_BE(*input);
input++;
tmp += GINT16_FROM_BE(*input);
input++;
stmp = tmp / 2;
*output++ = GINT16_TO_BE(stmp);
}
}
break;
default:
g_error("unknown format");
}
return length / 2;
}
static gint
fill_data_fields(MProFile *mprofile,
const guchar *buffer)
{
GwyDataField *dfield, *vpmask;
gdouble *data, *mask;
gdouble xreal, yreal, q;
const guchar *p;
guint n, id, i, j, ndata;
ndata = 0;
mprofile->intensity_data = NULL;
mprofile->intensity_mask = NULL;
mprofile->phase_data = NULL;
mprofile->phase_mask = NULL;
p = buffer + mprofile->header_size;
/* Intensity data */
n = mprofile->intens_xres * mprofile->intens_yres;
/* Enorce consistency */
if (!n && mprofile->nbuckets) {
g_warning("nbuckets > 0, but intensity data have zero dimension");
mprofile->nbuckets = 0;
}
if (mprofile->nbuckets) {
const guint16 *d16;
mprofile->intensity_data = g_new(GwyDataField*, mprofile->nbuckets);
mprofile->intensity_mask = g_new(GwyDataField*, mprofile->nbuckets);
q = mprofile->data_inverted ? -1.0 : 1.0;
if (mprofile->camera_res) {
xreal = mprofile->intens_xres * mprofile->camera_res;
yreal = mprofile->intens_yres * mprofile->camera_res;
}
else {
/* whatever */
xreal = mprofile->intens_xres;
yreal = mprofile->intens_yres;
}
for (id = 0; id < mprofile->nbuckets; id++) {
ndata++;
dfield = gwy_data_field_new(mprofile->intens_xres,
mprofile->intens_yres,
xreal, yreal,
FALSE);
vpmask = gwy_data_field_new_alike(dfield, FALSE);
gwy_data_field_fill(vpmask, 1.0);
data = gwy_data_field_get_data(dfield);
mask = gwy_data_field_get_data(vpmask);
d16 = (const guint16*)p;
for (i = 0; i < mprofile->intens_yres; i++) {
for (j = 0; j < mprofile->intens_xres; j++) {
guint v16 = GUINT16_FROM_BE(*d16);
if (v16 >= 65412) {
mask[i*mprofile->intens_xres + j] = 0.0;
}
else
*data = q*v16;
d16++;
data++;
}
}
set_units(dfield, mprofile, "");
if (!gwy_app_channel_remove_bad_data(dfield, vpmask))
gwy_object_unref(vpmask);
mprofile->intensity_data[id] = dfield;
mprofile->intensity_mask[id] = vpmask;
p += sizeof(guint16)*n;
}
}
/* Phase data */
n = mprofile->phase_xres * mprofile->phase_yres;
if (n) {
const gint32 *d32;
gint32 d;
ndata++;
i = 4096;
if (mprofile->phase_res == 1)
i = 32768;
q = mprofile->scale_factor * mprofile->obliquity_factor
* mprofile->wavelength_in/i;
if (mprofile->data_inverted)
q = -q;
gwy_debug("q: %g", q);
if (mprofile->camera_res) {
xreal = mprofile->phase_xres * mprofile->camera_res;
yreal = mprofile->phase_yres * mprofile->camera_res;
}
else {
/* whatever */
xreal = mprofile->phase_xres;
yreal = mprofile->phase_yres;
}
dfield = gwy_data_field_new(mprofile->phase_xres,
mprofile->phase_yres,
xreal, yreal,
FALSE);
vpmask = gwy_data_field_new_alike(dfield, FALSE);
gwy_data_field_fill(vpmask, 1.0);
data = gwy_data_field_get_data(dfield);
mask = gwy_data_field_get_data(vpmask);
d32 = (const gint32*)p;
for (i = 0; i < mprofile->phase_yres; i++) {
for (j = 0; j < mprofile->phase_xres; j++) {
d = GINT32_FROM_BE(*d32);
if (d >= 2147483640) {
mask[i*mprofile->phase_xres + j] = 0.0;
}
else
*data = q*d;
d32++;
data++;
}
}
set_units(dfield, mprofile, "m");
if (!gwy_app_channel_remove_bad_data(dfield, vpmask))
gwy_object_unref(vpmask);
mprofile->phase_data = dfield;
mprofile->phase_mask = vpmask;
p += sizeof(gint32)*n;
}
return ndata;
}
void ryostkl_light_layer_key_set_state(guint16 *key, gboolean state) {
guint16 tmp = GUINT16_FROM_BE(*key);
roccat_set_bit16(&tmp, RYOSTKL_LIGHT_LAYER_KEY_BIT_STATE, state);
*key = GUINT16_TO_BE(tmp);
}
static enum protocol_status _decode(
struct client *client,
const guint64 offset,
guint64 *len_,
guint64 *frame_len)
{
/*
* See http://tools.ietf.org/html/rfc6455#section-5.2 for more on what's
* going on here
*/
guint64 i;
guint64 len;
guint64 max;
guint64 total_len;
union {
guint32 i;
gchar c[4];
} mask;
union {
guint32 is[4];
__uint128_t i;
} mask128;
GString *rbuff = client->qev_client.rbuff;
gchar *str = rbuff->str + offset;
gchar *msg = rbuff->str + offset;
guint64 rbuff_len = rbuff->len - offset;
guint16 header_len = 0;
if ((str[0] & OPCODE) == OPCODE_CLOSE) {
qev_close(client, QEV_CLOSE_HUP);
return PROT_FATAL;
}
if (rbuff_len < 6) {
return PROT_AGAIN;
}
if ((str[0] & OPCODE) != OPCODE_TEXT) {
qev_close(client, RFC6455_UNSUPPORTED_OPCODE);
return PROT_FATAL;
}
if (!(str[1] & MASKED_BIT)) {
qev_close(client, RFC6455_NO_MASK);
return PROT_FATAL;
}
len = str[1] & MASK_LEN;
if (len <= PAYLOAD_SHORT) {
header_len = 6;
memcpy(mask.c, str + 2, 4);
} else if (len == PAYLOAD_MEDIUM) {
header_len = 8;
if (rbuff_len < header_len) {
return PROT_AGAIN;
}
len = GUINT16_FROM_BE(*((guint16*)(str + 2)));
memcpy(mask.c, str + 4, 4);
} else {
header_len = 14;
if (rbuff_len < header_len) {
return PROT_AGAIN;
}
len = GUINT64_FROM_BE(*((guint64*)(str + 2)));
memcpy(mask.c, str + 10, 4);
}
if (!qev_safe_uadd(header_len, len, &total_len)) {
return PROT_FATAL;
}
if (rbuff_len < total_len) {
return PROT_AGAIN;
}
*len_ = len;
*frame_len = total_len;
str += header_len;
/*
* The following mess warrants an explanation: it's quite a bit
* faster than the naive decode.
*
* Take a look at bench/bench_ws_decode.c for how much faster it is.
*
* The following steps are taken:
* 0) Create a 128 bit masking key from 4 32bit ones.
* 1) Gob through 128 bits at a time, until the next XOR would go past
* the end of the buffer.
* 2) Gob through 64 bits at a time, until the next XOR would overflow
* 3) Finish off going through any last characters.
*/
for (i = 0; i < sizeof(mask128) / sizeof(mask); i++) {
mask128.is[i] = mask.i;
}
max = len - (len & (sizeof(__uint128_t) - 1));
for (i = 0; i < max; i += sizeof(__uint128_t)) {
__uint128_t from = *((__uint128_t*)(str + i));
*((__uint128_t*)(msg + i)) = from ^ mask128.i;
}
max = len - (len & (sizeof(guint64) - 1));
for (; i < max; i += sizeof(guint64)) {
guint64 from = *((guint64*)(str + i));
*((guint64*)(msg + i)) = from ^ mask128.i;
}
for (; i < len; i++) {
msg[i] = str[i] ^ mask.c[i & 3];
}
*(msg + len) = '\0';
if (!g_utf8_validate(msg, len, NULL)) {
qev_close(client, RFC6455_NOT_UTF8);
return PROT_FATAL;
}
return PROT_OK;
}
gboolean ryostkl_light_layer_key_get_state(guint16 const *key) {
return roccat_get_bit16(GUINT16_FROM_BE(*key), RYOSTKL_LIGHT_LAYER_KEY_BIT_STATE);
}
