static GwyDataField*
read_data_field(const guchar *buffer,
gint xres,
gint yres,
NetCDFType type)
{
GwyDataField *dfield;
gdouble *data;
gint i;
dfield = gwy_data_field_new(xres, yres, 1.0, 1.0, FALSE);
data = gwy_data_field_get_data(dfield);
switch (type) {
case NC_BYTE:
case NC_CHAR:
{
const gint8 *d8 = (const gint8*)buffer;
for (i = 0; i < xres*yres; i++)
data[i] = d8[i];
}
break;
case NC_SHORT:
{
const gint16 *d16 = (const gint16*)buffer;
for (i = 0; i < xres*yres; i++)
data[i] = GINT16_FROM_BE(d16[i]);
}
break;
case NC_INT:
{
const gint32 *d32 = (const gint32*)buffer;
for (i = 0; i < xres*yres; i++)
data[i] = GINT32_FROM_BE(d32[i]);
}
break;
case NC_FLOAT:
for (i = 0; i < xres*yres; i++)
data[i] = gwy_get_gfloat_be(&buffer);
break;
case NC_DOUBLE:
for (i = 0; i < xres*yres; i++)
data[i] = gwy_get_gdouble_be(&buffer);
break;
default:
g_return_val_if_reached(dfield);
break;
}
return dfield;
}
static int convert_stereo_to_mono_s16be(struct xmms_convert_buffers* buf, void **data, int length)
{
gint16 *output = *data, *input = *data;
int i;
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);
}
return length / 2;
}
gboolean
g_vfs_afp_reply_read_int16 (GVfsAfpReply *reply, gint16 *val)
{
if ((reply->len - reply->pos) < 2)
return FALSE;
if (val)
*val = GINT16_FROM_BE (*((gint16 *)(reply->data + reply->pos)));
reply->pos += 2;
return TRUE;
}
void
io_recode_data_copy (const gchar *src, gchar *dest, DSType type, gsize nvals)
{
gsize i;
IOConstBufptr bsrc;
IOBufptr bdest;
bsrc.any = src;
bdest.any = dest;
switch (type) {
case DST_BIN:
case DST_I8:
case DST_TEXT:
memcpy (dest, src, nvals);
break;
case DST_I16:
for (i = 0; i < nvals; i++) {
*(bdest.i16) = GINT16_FROM_BE(*(bsrc.i16));
bdest.i16++;
bsrc.i16++;
}
break;
case DST_C64:
nvals *= 2;
/* fall through */
case DST_I32:
case DST_F32:
for (i = 0; i < nvals; i++) {
*(bdest.i32) = GINT32_FROM_BE(*(bsrc.i32));
bdest.i32++;
bsrc.i32++;
}
break;
case DST_I64:
case DST_F64:
for (i = 0; i < nvals; i++) {
*(bdest.i64) = GINT64_FROM_BE(*(bsrc.i64));
bdest.i64++;
bsrc.i64++;
}
break;
default:
g_error ("Unhandled data typecode %d!", type);
break;
}
}
void
io_recode_data_inplace (gchar *data, DSType type, gsize nvals)
{
gsize i;
IOBufptr bdata;
bdata.any = data;
switch (type) {
case DST_BIN:
case DST_I8:
case DST_TEXT:
break;
case DST_I16:
for (i = 0; i < nvals; i++) {
*(bdata.i16) = GINT16_FROM_BE(*(bdata.i16));
bdata.i16++;
}
break;
case DST_C64:
nvals *= 2;
/* fall through */
case DST_I32:
case DST_F32:
for (i = 0; i < nvals; i++) {
*(bdata.i32) = GINT32_FROM_BE(*(bdata.i32));
bdata.i32++;
}
break;
case DST_I64:
case DST_F64:
for (i = 0; i < nvals; i++) {
*(bdata.i64) = GINT64_FROM_BE(*(bdata.i64));
bdata.i64++;
}
break;
default:
g_error ("Unhandled data typecode %d!", type);
break;
}
}
/**
* qmi_utils_read_gint16_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 a signed 16-bit integer from the buffer. The number in the buffer is
* expected to be given in the byte order specified 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_gint16_from_buffer (const guint8 **buffer,
guint16 *buffer_size,
QmiEndian endian,
gint16 *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 = GINT16_FROM_BE (*out);
else
*out = GINT16_FROM_LE (*out);
print_read_bytes_trace ("gint16", &(*buffer)[0], out, 2);
*buffer = &((*buffer)[2]);
*buffer_size = (*buffer_size) - 2;
}
static VikDEM *vik_dem_read_srtm_hgt(const gchar *file_name, const gchar *basename, gboolean zip)
{
gint i, j;
VikDEM *dem;
off_t file_size;
gint16 *dem_mem = NULL;
gchar *dem_file = NULL;
const gint num_rows_3sec = 1201;
const gint num_rows_1sec = 3601;
gint num_rows;
GMappedFile *mf;
gint arcsec;
GError *error = NULL;
dem = g_malloc(sizeof(VikDEM));
dem->horiz_units = VIK_DEM_HORIZ_LL_ARCSECONDS;
dem->orig_vert_units = VIK_DEM_VERT_DECIMETERS;
/* TODO */
dem->min_north = atoi(basename+1) * 3600;
dem->min_east = atoi(basename+4) * 3600;
if ( basename[0] == 'S' )
dem->min_north = - dem->min_north;
if ( basename[3] == 'W' )
dem->min_east = - dem->min_east;
dem->max_north = 3600 + dem->min_north;
dem->max_east = 3600 + dem->min_east;
dem->columns = g_ptr_array_new();
dem->n_columns = 0;
if ((mf = g_mapped_file_new(file_name, FALSE, &error)) == NULL) {
g_error(_("Couldn't map file %s: %s"), file_name, error->message);
g_error_free(error);
g_free(dem);
return NULL;
}
file_size = g_mapped_file_get_length(mf);
dem_file = g_mapped_file_get_contents(mf);
if (zip) {
void *unzip_mem = NULL;
gulong ucsize;
if ((unzip_mem = unzip_hgt_file(dem_file, &ucsize)) == NULL) {
g_mapped_file_free(mf);
g_ptr_array_free(dem->columns, TRUE);
g_free(dem);
return NULL;
}
dem_mem = unzip_mem;
file_size = ucsize;
}
if (file_size == (num_rows_3sec * num_rows_3sec * sizeof(gint16)))
arcsec = 3;
else if (file_size == (num_rows_1sec * num_rows_1sec * sizeof(gint16)))
arcsec = 1;
else {
g_warning("%s(): file %s does not have right size", __PRETTY_FUNCTION__, basename);
g_mapped_file_free(mf);
g_free(dem);
return NULL;
}
num_rows = (arcsec == 3) ? num_rows_3sec : num_rows_1sec;
dem->east_scale = dem->north_scale = arcsec;
for ( i = 0; i < num_rows; i++ ) {
dem->n_columns++;
g_ptr_array_add ( dem->columns, g_malloc(sizeof(VikDEMColumn)) );
GET_COLUMN(dem,i)->east_west = dem->min_east + arcsec*i;
GET_COLUMN(dem,i)->south = dem->min_north;
GET_COLUMN(dem,i)->n_points = num_rows;
GET_COLUMN(dem,i)->points = g_malloc(sizeof(gint16)*num_rows);
}
int ent = 0;
for ( i = (num_rows - 1); i >= 0; i-- ) {
for ( j = 0; j < num_rows; j++ ) {
GET_COLUMN(dem,j)->points[i] = GINT16_FROM_BE(dem_mem[ent]);
ent++;
}
}
if (zip)
g_free(dem_mem);
g_mapped_file_free(mf);
return dem;
}
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 GwyDataField*
omicron_read_data(OmicronFile *ofile,
OmicronTopoChannel *channel,
GError **error)
{
GError *err = NULL;
GwyDataField *dfield;
GwySIUnit *siunit;
gchar *filename;
gdouble *data;
guchar *buffer;
const gint16 *d;
gdouble scale;
gsize size;
guint i, j, n;
gint power10 = 0;
filename = omicron_fix_file_name(ofile->filename, channel->filename, error);
if (!filename)
return NULL;
gwy_debug("Succeeded with <%s>", filename);
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
g_free(filename);
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
g_free(filename);
n = ofile->xres*ofile->yres;
if (err_SIZE_MISMATCH(error, 2*n, size, TRUE)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
scale = (channel->max_phys - channel->min_phys)
/(channel->max_raw - channel->min_raw);
dfield = gwy_data_field_new(ofile->xres, ofile->yres,
ofile->xreal, ofile->yreal,
FALSE);
data = gwy_data_field_get_data(dfield);
d = (const gint16*)buffer;
for (i = 0; i < ofile->yres; i++) {
for (j = 0; j < ofile->xres; j++)
data[(ofile->yres-1 - i)*ofile->xres + j]
= scale*GINT16_FROM_BE(d[i*ofile->xres + j]);
}
gwy_file_abandon_contents(buffer, size, NULL);
siunit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_xy(dfield, siunit);
g_object_unref(siunit);
siunit = gwy_si_unit_new_parse(channel->units, &power10);
gwy_data_field_set_si_unit_z(dfield, siunit);
g_object_unref(siunit);
if (power10)
gwy_data_field_multiply(dfield, pow10(power10));
return dfield;
}
gchar *
fread_unicode_string (gint32 *bytes_read,
gint32 *bytes_written,
const guint16 mod_len,
FILE *f,
GError **error)
{
/*
* Reads a utf-16 string from the file padded to a multiple of mod_len
* and returns a utf-8 string.
*/
gchar *utf8_str;
gunichar2 *utf16_str;
gint32 len;
gint32 i;
gint32 padded_len;
glong utf8_str_len;
*bytes_read = 0;
*bytes_written = -1;
if (fread (&len, 4, 1, f) < 1)
{
psd_set_error (feof (f), errno, error);
return NULL;
}
*bytes_read += 4;
len = GINT32_FROM_BE (len);
IFDBG(3) g_debug ("Unicode string length %d", len);
if (len == 0)
{
if (fseek (f, mod_len - 1, SEEK_CUR) < 0)
{
psd_set_error (feof (f), errno, error);
return NULL;
}
*bytes_read += (mod_len - 1);
*bytes_written = 0;
return NULL;
}
utf16_str = g_malloc (len * 2);
for (i = 0; i < len; ++i)
{
if (fread (&utf16_str[i], 2, 1, f) < 1)
{
psd_set_error (feof (f), errno, error);
return NULL;
}
*bytes_read += 2;
utf16_str[i] = GINT16_FROM_BE (utf16_str[i]);
}
if (mod_len > 0)
{
padded_len = len + 1;
while (padded_len % mod_len != 0)
{
if (fseek (f, 1, SEEK_CUR) < 0)
{
psd_set_error (feof (f), errno, error);
return NULL;
}
(*bytes_read)++;
padded_len++;
}
}
utf8_str = g_utf16_to_utf8 (utf16_str, len, NULL, &utf8_str_len, NULL);
*bytes_written = utf8_str_len;
g_free (utf16_str);
IFDBG(3) g_debug ("Unicode string: %s, bytes_read: %d, bytes_written: %d",
utf8_str, *bytes_read, *bytes_written);
return utf8_str;
}
static int get_version (CalcHandle* handle, CalcInfos* infos)
{
uint16_t pids[] = {
PID_PRODUCT_NAME, PID_MAIN_PART_ID,
PID_HW_VERSION, PID_LANGUAGE_ID, PID_SUBLANG_ID, PID_DEVICE_TYPE,
PID_BOOT_VERSION, PID_OS_VERSION,
PID_PHYS_RAM, PID_USER_RAM, PID_FREE_RAM,
PID_PHYS_FLASH, PID_USER_FLASH, PID_FREE_FLASH,
PID_LCD_WIDTH, PID_LCD_HEIGHT, PID_BATTERY, PID_OS_MODE,
};
const int size = sizeof(pids) / sizeof(uint16_t);
CalcParam **params;
int i = 0;
g_snprintf(update_->text, sizeof(update_->text), _("Getting version..."));
update_label();
memset(infos, 0, sizeof(CalcInfos));
params = cp_new_array(size);
TRYF(cmd_s_param_request(handle, size, pids));
TRYF(cmd_r_param_data(handle, size, params));
strncpy(infos->product_name, (char*)params[i]->data, params[i]->size);
infos->mask |= INFOS_PRODUCT_NAME;
i++;
g_snprintf(infos->main_calc_id, 10, "%02X%02X%02X%02X%02X",
params[i]->data[0], params[i]->data[1], params[i]->data[2], params[i]->data[3], params[i]->data[4]);
infos->mask |= INFOS_MAIN_CALC_ID;
strcpy(infos->product_id, infos->main_calc_id);
infos->mask |= INFOS_PRODUCT_ID;
i++;
infos->hw_version = (params[i]->data[0] << 8) | params[i]->data[1];
infos->mask |= INFOS_HW_VERSION; // hw version or model ?
i++;
infos->language_id = params[i]->data[0];
infos->mask |= INFOS_LANG_ID;
i++;
infos->sub_lang_id = params[i]->data[0];
infos->mask |= INFOS_SUB_LANG_ID;
i++;
infos->device_type = params[i]->data[1];
infos->mask |= INFOS_DEVICE_TYPE;
i++;
g_snprintf(infos->boot_version, 5, "%1i.%02i", params[i]->data[1], params[i]->data[2]);
infos->mask |= INFOS_BOOT_VERSION;
i++;
g_snprintf(infos->os_version, 5, "%1i.%02i", params[i]->data[1], params[i]->data[2]);
infos->mask |= INFOS_OS_VERSION;
i++;
infos->ram_phys = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_RAM_PHYS;
i++;
infos->ram_user = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_RAM_USER;
i++;
infos->ram_free = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_RAM_FREE;
i++;
infos->flash_phys = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_FLASH_PHYS;
i++;
infos->flash_user = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_FLASH_USER;
i++;
infos->flash_free = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_FLASH_FREE;
i++;
infos->lcd_width = GINT16_FROM_BE(*((uint16_t *)(params[i]->data)));
infos->mask |= INFOS_LCD_WIDTH;
i++;
infos->lcd_height = GINT16_FROM_BE(*((uint16_t *)(params[i]->data)));
infos->mask |= INFOS_LCD_HEIGHT;
i++;
infos->bits_per_pixel = 1;
infos->mask |= INFOS_BPP;
infos->battery = params[i]->data[0];
infos->mask |= INFOS_BATTERY;
i++;
infos->run_level = params[i]->data[0];
infos->mask |= INFOS_RUN_LEVEL;
i++;
switch(infos->hw_version)
{
case 0: infos->model = CALC_TI83P; break;
case 1: infos->model = CALC_TI83P; break;
case 2: infos->model = CALC_TI84P; break;
case 3: infos->model = CALC_TI84P; break;
}
infos->mask |= INFOS_CALC_MODEL;
cp_del_array(size, params);
return 0;
}
