gwy_convert_raw_data()

void
gwy_convert_raw_data (gconstpointer data,
                      gsize nitems,
                      gssize stride,
                      GwyRawDataType datatype,
                      GwyByteOrder byteorder,
                      gdouble *target,
                      gdouble scale,
                      gdouble offset);

Converts a block of raw data items to doubles.

Note that conversion from 64bit integral types may lose information as they have more bits than the mantissa of doubles. All other conversions should be exact.

For backward reading, pass -1 (or other negative value) as stride and point data to the last raw item instead of the first. More precisely, data must point to the first byte of the last raw value, not to the very last byte (for most data sizes this is intuitive, but 12bit data may involve some head scracthing). Zero stride is also allowed and results in target being filled with a constant value.

If the raw data size is not a whole number of bytes, parameter byteorder gives the order in which the pieces are packed into bytes. However, the usual order is to start from the high bits regardless of the machine endianness, so you normally always pass GWY_BYTE_ORDER_BIG_ENDIAN for fractional sized data.

For 12bit data only the big endian variant is defined at present. It means always storing the highest remaining bits of the 12bit value to the highest available bits of the byte, as TIFF and various cameras normally do.

For fractional sized data parameter stride specifies both the stride (always measured in raw values) and starting position within the first byte:

For example, consider conversion of 3 nibbles of 4bit data (in the usual big endian order). This is how they will be read to the output:

gwy_raw_data_size()

guint
gwy_raw_data_size (GwyRawDataType datatype);

Reports the size of a single raw data item in bytes.

For raw data types which are not whole bytes (whether smaller or larger, like 12bit), zero is returned. Use gwy_raw_data_size_bits() to get the size in bits.

gwy_raw_data_size_bits()

guint
gwy_raw_data_size_bits (GwyRawDataType datatype);

Reports the size of a single raw data item in bits.

If the data type is known to be whole bytes, gwy_raw_data_size() is usually simpler to use.

gwy_memcpy_byte_swap()

void
gwy_memcpy_byte_swap (const guint8 *source,
                      guint8 *dest,
                      gsize item_size,
                      gsize nitems,
                      gsize byteswap);

Copies a block of memory swapping bytes along the way.

The bits in byteswap correspond to groups of bytes to swap: if j-th bit is set, adjacent groups of 2j bits are swapped. For example, value 3 means items will be divided into couples (bit 1) of bytes and adjacent couples of bytes swapped, and then divided into single bytes (bit 0) and adjacent bytes swapped. The net effect is reversal of byte order in groups of four bytes. More generally, if you want to reverse byte order in groups of size 2^j, use byte swap pattern j-1.

When byteswap is zero, this function reduces to plain memcpy().

enum GwyRawDataType

Types of raw data.

They are used with gwy_convert_raw_data(). Multibyte types usually need to be complemented with GwyByteOrder to get a full type specification.

enum GwyByteOrder

Type of byte order.

Note all types are valid for all functions.