static gint
xmms_wave_read (xmms_xform_t *xform, xmms_sample_t *buf, gint len,
xmms_error_t *error)
{
xmms_wave_data_t *data;
gint ret;
g_return_val_if_fail (xform, -1);
data = xmms_xform_private_data_get (xform);
g_return_val_if_fail (data, -1);
ret = xmms_xform_read (xform, (gchar *) buf, len, error);
if (ret <= 0) {
return ret;
}
#if G_BYTE_ORDER == G_BIG_ENDIAN
if (data->bits_per_sample == 16) {
gint16 *s = (gint16 *) buf;
gint i;
for (i = 0; i < (ret / 2); i++) {
s[i] = GINT16_FROM_LE (s[i]);
}
}
#endif
return ret;
}
static inline guint16
get_short (gchar **p)
{
gint16 v = * (guint16 *) *p;
*p += 2;
return GINT16_FROM_LE (v);
}
static int convert_stereo_to_mono_s16le(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_LE(*input);
input++;
tmp += GINT16_FROM_LE(*input);
input++;
stmp = tmp / 2;
*output++ = GINT16_TO_LE(stmp);
}
return length / 2;
}
static gboolean
fill_data_fields(SurfFile *surffile,
const guchar *buffer,
GError **error)
{
GwySIUnit *siunit;
gdouble *data;
guint i, j;
surffile->dfield = gwy_data_field_new(surffile->xres,
surffile->yres,
surffile->xres*surffile->dx,
surffile->yres*surffile->dy,
FALSE);
data = gwy_data_field_get_data(surffile->dfield);
switch (surffile->pointsize) {
case 16:
{
const gint16 *row, *d16 = (const gint16*)buffer;
for (i = 0; i < surffile->xres; i++) {
row = d16 + i*surffile->yres;
for (j = 0; j < surffile->yres; j++)
*(data++) = GINT16_FROM_LE(row[j]) * surffile->dz;
}
}
break;
case 32:
{
const gint32 *row, *d32 = (const gint32*)buffer;
for (i = 0; i < surffile->xres; i++) {
row = d32 + i*surffile->yres;
for (j = 0; j < surffile->yres; j++)
*(data++) = GINT32_FROM_LE(row[j]) * surffile->dz;
}
}
break;
default:
err_BPP(error, surffile->pointsize);
return FALSE;
break;
}
siunit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_xy(surffile->dfield, siunit);
g_object_unref(siunit);
siunit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_z(surffile->dfield, siunit);
g_object_unref(siunit);
return TRUE;
}
static GwyDataField*
mif_read_data_field(const MIFImageHeader *image_header,
const MIFBlock *block,
const guchar *buffer,
gsize size,
GError **error)
{
gint xres = image_header->setup.xres;
gint yres = image_header->setup.yres;
gdouble xreal = image_header->setup.xreal;
gdouble yreal = image_header->setup.yreal;
gdouble xoff = image_header->setup.xoff;
gdouble yoff = image_header->setup.yoff;
gdouble q = image_header->configuration.scan_int_to_meter;
GwyDataField *dfield;
gdouble *data;
const gint16 *d16;
gint i, j;
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
return NULL;
if (!block->size || block->offset > size || block->size > size
|| block->offset + block->size > size) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Image data are outside the file."));
return NULL;
}
if (err_SIZE_MISMATCH(error, xres*yres*sizeof(gint16), block->size, FALSE))
return NULL;
dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE);
gwy_data_field_set_xoffset(dfield, xoff);
gwy_data_field_set_yoffset(dfield, yoff);
data = gwy_data_field_get_data(dfield);
d16 = (const gint16*)(buffer + block->offset);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m");
// FIXME: Don't know why this factor. It seems to match what MIF spmview
// profile reader shows though.
q *= 1.0e4;
for (i = 0; i < yres; i++) {
for (j = 0; j < yres; j++) {
data[(yres-1 - i)*xres + j] = q*GINT16_FROM_LE(d16[i*xres + j]);
}
}
return dfield;
}
static GwyDataField*
rhkspm32_read_data(RHKPage *rhkpage)
{
GwyDataField *dfield;
const guint16 *p;
GwySIUnit *siunit;
gdouble *data;
const gchar *s;
gdouble q;
gint power10;
guint i, j, xres, yres;
p = (const guint16*)(rhkpage->buffer + rhkpage->data_offset);
xres = rhkpage->xres;
yres = rhkpage->yres;
// the scales are no longer gurunteed to be positive,
// so they must be "fixed" here (to enable spectra)
dfield = gwy_data_field_new(xres, yres,
xres*fabs(rhkpage->x.scale),
yres*fabs(rhkpage->y.scale),
FALSE);
data = gwy_data_field_get_data(dfield);
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++)
data[i*xres + xres-1 - j] = GINT16_FROM_LE(p[i*xres + j]);
}
siunit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string_parse(siunit, rhkpage->x.units, &power10);
if (power10) {
q = pow10(power10);
gwy_data_field_set_xreal(dfield, q*gwy_data_field_get_xreal(dfield));
gwy_data_field_set_yreal(dfield, q*gwy_data_field_get_yreal(dfield));
}
siunit = gwy_data_field_get_si_unit_z(dfield);
s = rhkpage->z.units;
/* Fix some silly units */
if (gwy_strequal(s, "N/sec"))
s = "s^-1";
gwy_si_unit_set_from_string_parse(siunit, s, &power10);
q = pow10(power10);
gwy_data_field_multiply(dfield, q*fabs(rhkpage->z.scale));
gwy_data_field_add(dfield, q*rhkpage->z.offset);
return dfield;
}
static gboolean
read_binary_data(guint res,
gdouble *data,
const guchar *buffer)
{
const guint16 *p = (const guint16*)buffer;
guint i, j;
for (i = 0; i < res*res; i++) {
j = (res - 1 - (i % res))*res + i/res;
data[j] = GINT16_FROM_LE(p[i]);
}
return TRUE;
}
/* FIXME: We hope Nanoscope files always use little endian, because we only
* have seen them on Intel. */
static gboolean
read_binary_data(gint n, gdouble *data,
gchar *buffer,
gint bpp,
GError **error)
{
gint i;
gdouble q;
q = 1.0/(1 << (8*bpp));
switch (bpp) {
case 1:
for (i = 0; i < n; i++)
data[i] = q*buffer[i];
break;
case 2:
{
gint16 *p = (gint16*)buffer;
for (i = 0; i < n; i++)
data[i] = q*GINT16_FROM_LE(p[i]);
}
break;
case 4:
{
gint32 *p = (gint32*)buffer;
for (i = 0; i < n; i++)
data[i] = q*GINT32_FROM_LE(p[i]);
}
break;
default:
err_BPP(error, bpp);
return FALSE;
break;
}
return TRUE;
}
/**
* 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 void
read_data_field(GwyDataField *dfield,
EZDSection *section)
{
gdouble *data;
gdouble q, z0;
guint i, j;
gint xres, yres;
g_assert(section->data);
xres = section->xres;
yres = section->yres;
gwy_data_field_resample(dfield, xres, yres, GWY_INTERPOLATION_NONE);
data = gwy_data_field_get_data(dfield);
q = 1 << section->bitdepth;
z0 = q/2.0;
if (section->bitdepth == 8) {
const gchar *p = section->data;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++)
data[i*xres + j] = (p[(yres-1 - i)*xres + j] + z0)/q;
}
}
else if (section->bitdepth == 16) {
const gint16 *p = (const gint16*)section->data;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
data[i*xres + j] = GINT16_FROM_LE(p[(yres-1 - i)*xres + j]);
data[i*xres + j] = (data[i*xres + j] + z0)/q;
}
}
}
else
g_warning("Damn! Bit depth %d is not implemented", section->bitdepth);
}
static GwyDataField*
mif_read_data_field(const MIFImageHeader *image_header,
const MIFBlock *block,
const guchar *buffer,
gsize size,
GError **error)
{
const MIFScanSetup *setup = &image_header->setup;
const MIFImageConfiguration *configuration = &image_header->configuration;
gint xres = setup->xres;
gint yres = setup->yres;
gdouble xreal = setup->xreal * image_header->configuration.xcal;
gdouble yreal = setup->yreal * image_header->configuration.ycal;
gdouble xoff = setup->xoff;
gdouble yoff = setup->yoff;
gdouble q = configuration->zcal/65536.0;
GwyDataField *dfield;
gdouble *data, *linecorrdata = NULL;
gsize datasize;
const gint16 *d16;
gint i, j;
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
return NULL;
if (!block->size || block->offset > size || block->size > size
|| block->offset + block->size > size) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Image data are outside the file."));
return NULL;
}
datasize = xres*yres*sizeof(gint16);
if (err_SIZE_MISMATCH(error, datasize, block->size, FALSE))
return NULL;
if (datasize + yres*sizeof(gint16) <= block->size) {
gwy_debug("There may be %u correction data after the image.", yres);
linecorrdata = g_new(gdouble, yres);
d16 = (const gint16*)(buffer + block->offset + datasize);
for (i = 0; i < yres; i++) {
linecorrdata[i] = pow(2.0, d16[i] - 13);
gwy_debug("corr[%u] %g", i, linecorrdata[i]);
}
}
dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE);
gwy_data_field_set_xoffset(dfield, xoff);
gwy_data_field_set_yoffset(dfield, yoff);
data = gwy_data_field_get_data(dfield);
d16 = (const gint16*)(buffer + block->offset);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m");
// XXX: Don't know why this range. A user got it from DME. Have no idea
// why scan_int_to_meter does not appear here.
if (!configuration->z_linearized)
q *= 15e-6;
else
q *= 20e-6;
for (i = 0; i < yres; i++) {
gdouble qi = linecorrdata ? q*linecorrdata[i] : q;
for (j = 0; j < yres; j++) {
data[(yres-1 - i)*xres + j] = qi*GINT16_FROM_LE(d16[i*xres + j]);
}
}
g_free(linecorrdata);
return dfield;
}
static GwyDataField*
unisoku_read_data_field(const guchar *buffer,
gsize size,
UnisokuFile *ufile,
GError **error)
{
gint i, n, power10;
const gchar *unit;
GwyDataField *dfield;
GwySIUnit *siunit;
gdouble q, pmin, pmax, rmin, rmax;
gdouble *data;
n = ufile->xres * ufile->yres;
if (err_SIZE_MISMATCH(error, n*type_sizes[ufile->data_type], size, FALSE))
return NULL;
dfield = gwy_data_field_new(ufile->xres, ufile->yres,
fabs((ufile->end_x - ufile->start_x)),
fabs((ufile->end_y - ufile->start_y)),
FALSE);
data = gwy_data_field_get_data(dfield);
/* FIXME: what to do when ascii_flag is set? */
switch (ufile->data_type) {
case UNISOKU_UINT8:
for (i = 0; i < n; i++)
data[i] = buffer[i];
break;
case UNISOKU_SINT8:
for (i = 0; i < n; i++)
data[i] = (signed char)buffer[i];
break;
case UNISOKU_UINT16:
{
const guint16 *pdata = (const guint16*)buffer;
for (i = 0; i < n; i++)
data[i] = GUINT16_FROM_LE(pdata[i]);
}
break;
case UNISOKU_SINT16:
{
const gint16 *pdata = (const gint16*)buffer;
for (i = 0; i < n; i++)
data[i] = GINT16_FROM_LE(pdata[i]);
}
break;
case UNISOKU_FLOAT:
for (i = 0; i < n; i++)
data[i] = gwy_get_gfloat_le(&buffer);
break;
default:
g_return_val_if_reached(NULL);
break;
}
unit = ufile->unit_x;
if (!*unit)
unit = "nm";
siunit = gwy_si_unit_new_parse(unit, &power10);
gwy_data_field_set_si_unit_xy(dfield, siunit);
q = pow10((gdouble)power10);
gwy_data_field_set_xreal(dfield, q*gwy_data_field_get_xreal(dfield));
gwy_data_field_set_yreal(dfield, q*gwy_data_field_get_yreal(dfield));
g_object_unref(siunit);
unit = ufile->unit_z;
/* XXX: No fallback yet, just make z unitless */
siunit = gwy_si_unit_new_parse(unit, &power10);
gwy_data_field_set_si_unit_z(dfield, siunit);
q = pow10((gdouble)power10);
pmin = q*ufile->min_z;
pmax = q*ufile->max_z;
rmin = ufile->min_raw_z;
rmax = ufile->max_raw_z;
gwy_data_field_multiply(dfield, (pmax - pmin)/(rmax - rmin));
gwy_data_field_add(dfield, (pmin*rmax - pmax*rmin)/(rmax - rmin));
g_object_unref(siunit);
return dfield;
}
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 int loadfile(struct sr_input *in, const char *filename)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
struct sr_datafeed_analog analog;
struct sr_config *src;
struct context *ctx;
float fdata[CHUNK_SIZE];
uint64_t sample;
int num_samples, chunk_samples, s, c, fd, l;
char buf[CHUNK_SIZE];
ctx = in->sdi->priv;
/* Send header packet to the session bus. */
std_session_send_df_header(in->sdi, LOG_PREFIX);
packet.type = SR_DF_META;
packet.payload = &meta;
src = sr_config_new(SR_CONF_SAMPLERATE,
g_variant_new_uint64(ctx->samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
sr_config_free(src);
if ((fd = open(filename, O_RDONLY)) == -1)
return SR_ERR;
lseek(fd, 40, SEEK_SET);
l = read(fd, buf, 4);
num_samples = GUINT32_FROM_LE((uint32_t)*(buf));
num_samples /= ctx->samplesize / ctx->num_channels;
while (TRUE) {
if ((l = read(fd, buf, CHUNK_SIZE)) < 1)
break;
chunk_samples = l / ctx->samplesize / ctx->num_channels;
for (s = 0; s < chunk_samples; s++) {
for (c = 0; c < ctx->num_channels; c++) {
sample = 0;
memcpy(&sample, buf + s * ctx->samplesize + c, ctx->samplesize);
switch (ctx->samplesize) {
case 1:
/* 8-bit PCM samples are unsigned. */
fdata[s + c] = (uint8_t)sample / 255.0;
break;
case 2:
fdata[s + c] = GINT16_FROM_LE(sample) / 32767.0;
break;
case 4:
fdata[s + c] = GINT32_FROM_LE(sample) / 65535.0;
break;
}
}
}
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
analog.probes = in->sdi->probes;
analog.num_samples = chunk_samples;
analog.mq = 0;
analog.unit = 0;
analog.data = fdata;
sr_session_send(in->sdi, &packet);
}
close(fd);
packet.type = SR_DF_END;
sr_session_send(in->sdi, &packet);
return SR_OK;
}
static GwyContainer*
burleigh_exp_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
gchar *buffer = NULL;
BurleighExpHeader header;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield;
gdouble *data;
guint i, n;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < MIN_FILE_SIZE + 2) {
err_TOO_SHORT(error);
g_free(buffer);
return NULL;
}
if (!burleigh_exp_read_header(&header, buffer, error))
goto fail;
n = header.xres * header.yres;
if (header.binary) {
if (header.bpp != 16) {
err_BPP(error, header.bpp);
goto fail;
}
else if (err_SIZE_MISMATCH(error, header.length + 2*n, size, TRUE))
goto fail;
}
dfield = gwy_data_field_new(header.xres, header.yres,
header.xscale, header.yscale,
FALSE);
data = gwy_data_field_get_data(dfield);
if (header.binary) {
const gint16 *d16 = (const gint16*)(buffer + header.length);
for (i = 0; i < n; i++)
data[i] = GINT16_FROM_LE(d16[i]);
}
else {
gchar *p = buffer + header.length;
for (i = 0; i < n; i++)
data[i] = strtol(p, &p, 10);
}
gwy_data_field_multiply(dfield, header.zscale/32768.0);
/* Units references released in free_header() */
gwy_data_field_set_si_unit_xy(dfield, header.xyunits);
gwy_data_field_set_si_unit_z(dfield, header.zunits);
container = gwy_container_new();
gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield);
g_object_unref(dfield);
gwy_app_channel_title_fall_back(container, 0);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
fail:
free_header(&header);
g_free(buffer);
return container;
}
static GwySpectra*
rhkspm32_read_spectra(RHKPage *rhkpage)
{
guint i, j;
gdouble *data;
GwySIUnit *siunit = NULL;
GwyDataLine *dline;
GwySpectra *spectra = NULL;
GPtrArray *spectrum = NULL;
// i'm leaving this alone, though it probably doesn't make sense,
// and i should just create graphs straight away - but in case of
// future use, i'll just convert the data later to graphs
// xres stores number of data points per spectra,
// yres stores the number of spectra
// reading data
gwy_debug("rhk-spm32: %d spectra in this page\n", rhkpage->yres);
for (i = 0; i < rhkpage->yres; i++) {
dline = gwy_data_line_new(rhkpage->xres, rhkpage->x.scale, FALSE);
gwy_data_line_set_offset(dline, (rhkpage->x.offset));
data = gwy_data_line_get_data(dline);
// store line data in physical units - which are the z values, not y
if ((rhkpage->data_type) == RHK_DATA_INT16) {
const guint16 *p = (const guint16*)(rhkpage->buffer
+ rhkpage->data_offset);
for (j = 0; j < rhkpage->xres; j++) {
data[j] = GINT16_FROM_LE(p[i*(rhkpage->xres) + j])
*(rhkpage->z.scale)+(rhkpage->z.offset);
}
}
else if ((rhkpage->data_type) == RHK_DATA_SINGLE) {
const guchar *p = (const guchar*)(rhkpage->buffer
+ rhkpage->data_offset);
for (j = 0; j < rhkpage->xres; j++) {
data[j] = gwy_get_gfloat_le(&p)*rhkpage->z.scale
+ rhkpage->z.offset;
}
}
siunit = gwy_si_unit_new(rhkpage->x.units);
gwy_data_line_set_si_unit_x(dline, siunit);
g_object_unref(siunit);
// the y units (and data) for a 1D graph are stored in Z in the rhk
// spm32 format!
/* Fix "/\xfbHz" to "/Hz".
* XXX: It might be still wrong as the strange character might mean
* sqrt. */
if (g_str_has_suffix(rhkpage->z.units, "/\xfbHz")) {
gchar *s = gwy_strkill(g_strdup(rhkpage->z.units), "\xfb");
siunit = gwy_si_unit_new(s);
g_free(s);
}
else
siunit = gwy_si_unit_new(rhkpage->z.units);
gwy_data_line_set_si_unit_y(dline, siunit);
g_object_unref(siunit);
if (!spectrum)
spectrum = g_ptr_array_sized_new(rhkpage->yres);
g_ptr_array_add(spectrum, dline);
}
gwy_debug("rhk-spm32: finished parsing sps data\n");
spectra = gwy_spectra_new();
for (i = 0; i < rhkpage->yres; i++) {
dline = g_ptr_array_index(spectrum, i);
// since RHK spm32 does not record where it took the spectra,
// i'm setting these to zero
gwy_spectra_add_spectrum(spectra, dline, 0, 0);
g_object_unref(dline);
}
gwy_spectra_set_title(spectra, rhkpage->label);
if (spectrum)
g_ptr_array_free(spectrum, TRUE);
return spectra;
}
static void
fill_data_fields(SurfFile *surffile,
const guchar *buffer)
{
gdouble *data;
guint i, j;
surffile->dfield = GWY_DATA_FIELD(gwy_data_field_new(surffile->xres,
surffile->yres,
surffile->xres*surffile->dx,
surffile->yres*surffile->dy,
TRUE));
data = gwy_data_field_get_data(surffile->dfield);
switch (surffile->pointsize) {
case 16:
{
const gint16 *row, *d16 = (const gint16*)buffer;
for (i = 0; i < surffile->xres; i++) {
row = d16 + i*surffile->yres;
for (j = 0; j < surffile->yres; j++)
*(data++) = GINT16_FROM_LE(row[j]) * surffile->dz;
}
}
break;
case 32:
{
const gint32 *row, *d32 = (const gint32*)buffer;
for (i = 0; i < surffile->xres; i++) {
row = d32 + i*surffile->yres;
for (j = 0; j < surffile->yres; j++)
*(data++) = GINT32_FROM_LE(row[j]) * surffile->dz;
}
}
break;
default:
g_warning("Wrong data size: %d", surffile->pointsize);
break;
}
/*
data = gwy_data_field_get_data(surffile->dfield);
for (i = 0; i < surffile->xres; i++) {
for (j = 0; j < surffile->yres; j++) {
if (surffile->pointsize == 16) {
*(data++) = (gdouble)*(gint16*)buffer*surffile->dz;
buffer += 2;
}
else {
*(data++) = ((gdouble)*(gint32*)buffer)*surffile->dz;
buffer += 4;
}
}
}
*/
if (surffile->dx > surffile->dy)
gwy_data_field_resample(surffile->dfield, (gint)((gdouble)(surffile->xres)*surffile->dx/surffile->dy),
surffile->yres, GWY_INTERPOLATION_BILINEAR);
else if (surffile->dy > surffile->dx)
gwy_data_field_resample(surffile->dfield, surffile->xres,
(gint)((gdouble)(surffile->yres)*surffile->dy/surffile->dx),
GWY_INTERPOLATION_BILINEAR);
}
static GwyContainer*
burleigh_load(const gchar *filename)
{
GwySIUnit *unit;
GwyContainer *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize size = 0;
GError *err = NULL;
IMGFile imgfile;
GwyDataField *dfield;
gdouble *data;
const gint16 *d;
gdouble scale;
guint i;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
g_warning("Cannot get file contents");
g_clear_error(&err);
return NULL;
}
if (size < HEADER_SIZE_MIN + 2) {
g_warning("File is too short");
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
memset(&imgfile, 0, sizeof(imgfile));
p = buffer;
imgfile.version = get_FLOAT(&p);
imgfile.version_int = ROUND(10*imgfile.version);
if (imgfile.version_int == 21) {
d = burleigh_load_v21(&imgfile, buffer, size);
if (!d) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
}
else {
g_warning("File format version %.f is not supported", imgfile.version);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
dfield = GWY_DATA_FIELD(gwy_data_field_new(imgfile.xres, imgfile.yres,
Angstrom*imgfile.xrange,
Angstrom*imgfile.yrange,
FALSE));
data = gwy_data_field_get_data(dfield);
scale = Angstrom * imgfile.z_gain * imgfile.zrange;
for (i = 0; i < imgfile.xres*imgfile.yres; i++)
data[i] = scale * GINT16_FROM_LE(d[i]);
gwy_file_abandon_contents(buffer, size, NULL);
unit = GWY_SI_UNIT(gwy_si_unit_new("m"));
gwy_data_field_set_si_unit_xy(dfield, unit);
g_object_unref(unit);
container = GWY_CONTAINER(gwy_container_new());
switch (imgfile.data_type) {
case BURLEIGH_CURRENT:
unit = GWY_SI_UNIT(gwy_si_unit_new("A"));
gwy_container_set_string_by_name(container, "/filename/title",
g_strdup("Current"));
break;
case BURLEIGH_TOPOGRAPHY:
unit = GWY_SI_UNIT(gwy_si_unit_new("m"));
gwy_container_set_string_by_name(container, "/filename/title",
g_strdup("Topography"));
break;
default:
unit = GWY_SI_UNIT(gwy_si_unit_new("m"));
break;
}
gwy_data_field_set_si_unit_z(dfield, unit);
g_object_unref(unit);
gwy_container_set_object_by_name(container, "/0/data", (GObject*)dfield);
g_object_unref(dfield);
return container;
}
static GwyContainer*
pni_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
static const GwyEnum titles[] = {
{ "Height", DATA_TYPE_HGT, },
{ "Sens", DATA_TYPE_SEN, },
{ "Dem", DATA_TYPE_DEM, },
{ "Error", DATA_TYPE_ERR, },
{ "L-R", DATA_TYPE_L_R, },
};
GwyContainer *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
const guchar *p;
gint i, xres, yres;
PNIDataType data_type;
PNIValueType value_type;
PNIDirection direction;
gdouble xreal, yreal, zscale;
gdouble *data;
const gint16 *d16;
GwySIUnit *siunit;
const gchar *title;
gchar *s;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < DATA_START + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
p = buffer + DATA_HEADER_START + RESOLUTION_OFFSET;
xres = gwy_get_guint32_le(&p);
yres = gwy_get_guint32_le(&p);
gwy_debug("%d %d", xres, yres);
if (err_DIMENSION(error, xres)
|| err_DIMENSION(error, yres)
|| err_SIZE_MISMATCH(error, DATA_START + 2*xres*yres, size, TRUE)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
p = buffer + DATA_HEADER_START;
data_type = p[DATA_TYPE_OFFSET];
value_type = p[VALUE_TYPE_OFFSET];
direction = p[DIRECTION_OFFSET];
p = buffer + DATA_HEADER_START + REAL_SIZE_OFFSET;
xreal = gwy_get_gfloat_le(&p);
yreal = gwy_get_gfloat_le(&p);
/* Use negated positive conditions to catch NaNs */
if (!((xreal = fabs(xreal)) > 0)) {
g_warning("Real x size is 0.0, fixing to 1.0");
xreal = 1.0;
}
if (!((yreal = fabs(yreal)) > 0)) {
g_warning("Real y size is 0.0, fixing to 1.0");
yreal = 1.0;
}
xreal *= Micrometer;
yreal *= Micrometer;
p = buffer + DATA_HEADER_START + VALUE_SCALE_OFFSET;
zscale = gwy_get_gfloat_le(&p);
dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE);
data = gwy_data_field_get_data(dfield);
d16 = (const gint16*)(buffer + DATA_START);
for (i = 0; i < xres*yres; i++)
data[i] = zscale*GINT16_FROM_LE(d16[i])/65536.0;
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);
switch (value_type) {
case VALUE_TYPE_NM:
siunit = gwy_si_unit_new("m");
gwy_data_field_multiply(dfield, Nanometer);
break;
case VALUE_TYPE_MV:
siunit = gwy_si_unit_new("V");
gwy_data_field_multiply(dfield, Milivolt);
break;
default:
g_warning("Value type %d is unknown", value_type);
siunit = gwy_si_unit_new(NULL);
break;
}
gwy_data_field_set_si_unit_z(dfield, siunit);
g_object_unref(siunit);
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
title = gwy_enum_to_string(data_type, titles, G_N_ELEMENTS(titles));
if (title) {
s = g_strdup_printf("%s (%s)",
title,
direction ? "Forward" : "Backward");
gwy_container_set_string_by_name(container, "/0/data/title", s);
}
else
g_warning("Data type %d is unknown", data_type);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
return container;
}
static GwyContainer*
burleigh_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwySIUnit *unit;
GwyContainer *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize size = 0;
GError *err = NULL;
IMGFile imgfile;
GwyDataField *dfield;
gdouble *data;
const gint16 *d;
gdouble zoom;
guint i;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < HEADER_SIZE_MIN + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
gwy_clear(&imgfile, 1);
p = buffer;
imgfile.version = gwy_get_gfloat_le(&p);
imgfile.version_int = GWY_ROUND(10*imgfile.version);
if (imgfile.version_int == 21) {
d = burleigh_load_v21(&imgfile, buffer, size, error);
if (!d) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
}
else {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("File format version %.1f is not supported."),
imgfile.version);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
zoom = burleigh_get_zoom_v21(&imgfile);
if (err_DIMENSION(error, imgfile.xres)
|| err_DIMENSION(error, imgfile.yres)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
dfield = gwy_data_field_new(imgfile.xres, imgfile.yres,
Angstrom*imgfile.xrange/zoom,
Angstrom*imgfile.yrange/zoom,
FALSE);
data = gwy_data_field_get_data(dfield);
for (i = 0; i < imgfile.xres*imgfile.yres; i++)
data[i] = GINT16_FROM_LE(d[i])*imgfile.zrange/4095.0;
gwy_file_abandon_contents(buffer, size, NULL);
unit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_xy(dfield, unit);
g_object_unref(unit);
container = gwy_container_new();
switch (imgfile.data_type) {
case BURLEIGH_CURRENT:
unit = gwy_si_unit_new("A");
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Current"));
gwy_data_field_multiply(dfield, Picoampere);
break;
case BURLEIGH_TOPOGRAPHY:
unit = gwy_si_unit_new("m");
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
gwy_data_field_multiply(dfield, Angstrom);
break;
default:
unit = gwy_si_unit_new("m");
break;
}
gwy_data_field_set_si_unit_z(dfield, unit);
g_object_unref(unit);
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
return container;
}
static GwyDataField*
sdfile_read_data_bin(SDFile *sdfile)
{
gint i, n;
GwyDataField *dfield;
gdouble *data;
const guchar *p;
dfield = gwy_data_field_new(sdfile->xres, sdfile->yres,
sdfile->xres * sdfile->xscale,
sdfile->yres * sdfile->yscale,
FALSE);
data = gwy_data_field_get_data(dfield);
n = sdfile->xres * sdfile->yres;
/* We assume Intel byteorder, although the format does not specify
* any order. But it was developed in PC context... */
switch (sdfile->data_type) {
case SDF_UINT8:
for (i = 0; i < n; i++)
data[i] = sdfile->data[i];
break;
case SDF_SINT8:
for (i = 0; i < n; i++)
data[i] = (signed char)sdfile->data[i];
break;
case SDF_UINT16:
{
const guint16 *pdata = (const guint16*)(sdfile->data);
for (i = 0; i < n; i++)
data[i] = GUINT16_FROM_LE(pdata[i]);
}
break;
case SDF_SINT16:
{
const gint16 *pdata = (const gint16*)(sdfile->data);
for (i = 0; i < n; i++)
data[i] = GINT16_FROM_LE(pdata[i]);
}
break;
case SDF_UINT32:
{
const guint32 *pdata = (const guint32*)(sdfile->data);
for (i = 0; i < n; i++)
data[i] = GUINT32_FROM_LE(pdata[i]);
}
break;
case SDF_SINT32:
{
const gint32 *pdata = (const gint32*)(sdfile->data);
for (i = 0; i < n; i++)
data[i] = GINT32_FROM_LE(pdata[i]);
}
break;
case SDF_FLOAT:
p = sdfile->data;
for (i = 0; i < n; i++)
data[i] = gwy_get_gfloat_le(&p);
break;
case SDF_DOUBLE:
p = sdfile->data;
for (i = 0; i < n; i++)
data[i] = gwy_get_gdouble_le(&p);
break;
default:
g_object_unref(dfield);
g_return_val_if_reached(NULL);
break;
}
return dfield;
}