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; }