int unpack_item(uint16_t type, uint16_t id, void * inbuf, uint16_t length, tlv_t * outtlv)
{
uint32_t outsize = 0;
int ret = 0;
void * value = NULL;
message_t * newmsg = NULL;
value = malloc(length);
if (NULL == value) {
return -1;
}
switch (id) {
case TLV_TYPE_INT8:
case TLV_TYPE_UINT8:
outsize = length;
ret = pack_int8((uint8_t *)inbuf, (uint8_t *)value, &outsize);
break;
case TLV_TYPE_INT16:
case TLV_TYPE_UINT16:
outsize = length;
ret = unpack_int16((uint16_t *)inbuf, (uint16_t *)value, &outsize);
break;
case TLV_TYPE_INT32:
case TLV_TYPE_UINT32:
outsize = length;
ret = unpack_int32((uint32_t *)inbuf, (uint32_t *)value, &outsize);
break;
case TLV_TYPE_BYTES:
outsize = length;
ret = pack_bytes(inbuf, length, value, &outsize);
break;
case TLV_TYPE_MSG:
newmsg = msg_unpack((uint8_t *)inbuf, length);
if (NULL == newmsg) {
free(value);
return -1;
}
memcpy(value, newmsg, MSG_SIZE(newmsg));
free(newmsg);
break;
default:
free(value);
return -1;
}
if (0 != ret) {
free(value);
}
outtlv->id = id;
outtlv->type = type;
outtlv->length = length;
outtlv->value = value;
return ret;
}
int
unpack_value(tlv_type_t type, uint16_t id, void *inbuf, uint16_t length, tlv_t *out_tlv) {
int b = 0;
uint32_t out_sz = 0;
void *value = NULL;
if (NULL == inbuf || NULL == out_tlv) {
return -1;
}
value = malloc(length);
if (NULL == value) {
return -1;
}
switch(type) {
case TLV_TYPE_INT8:
case TLV_TYPE_UINT8:
b = pack_int8((uint8_t*)inbuf, (uint8_t*)value, &out_sz);
break;
case TLV_TYPE_INT16:
case TLV_TYPE_UINT16:
b = unpack_int16((uint16_t*)inbuf, (uint16_t*)value, &out_sz);
break;
case TLV_TYPE_INT32:
case TLV_TYPE_UINT32:
b = unpack_int32((uint32_t*)inbuf, (uint32_t*)value, &out_sz);
break;
case TLV_TYPE_BYTES:
out_sz = length;
b = pack_bytes(inbuf, length, value, &out_sz);
break;
default:
b = -1;
break;
}
if (b != 0) {
free(value);
return -1;
}
out_tlv->id = id;
out_tlv->type = type;
out_tlv->length = length;
out_tlv->value = value;
return b;
}
virtual void unpack(const std::vector<uint8_t>& bytes)
{
int32_t unpackedInt;
uint32_t unpackedUint;
float unpackedFloat;
unpack_int32(&(bytes[0]), unpackedInt);
unpack_uint32(&(bytes[4]), unpackedUint);
unpack_float32(&(bytes[8]), unpackedFloat);
AssertEquals(testInt, unpackedInt);
AssertEquals(testUint, unpackedUint);
AssertEquals(testFloat, unpackedFloat);
}
// Assuming http://www.seg.org/documents/10161/77915/seg_y_rev1.pdf
int opesci_read_model_segy(const char *filename, std::vector<float> &array, int dim[], float spacing[])
{
std::ifstream infile(filename);
if(!infile.good()) {
std::cerr<<"ERROR ("<<__FILE__<<", "<<__LINE__<<"): Failed to open SEG-Y file "<<filename<<std::endl;
return -1;
}
// Get the size of the file.
infile.seekg (0, infile.end);
long filesize = infile.tellg();
// Read in header
char header_buffer[3600];
infile.seekg(0, infile.beg);
infile.read(header_buffer, 3600);
bool swap_endian=false;
int ntraces, tracesize, format_code;
int Nx, Ny, Nz;
for(int i=0; i<2; i++) { // Enables a re-try of header read.
// 3201 - 3204 Job identification number.
// 3205 - 3208 Line number.
// 3209 - 3212 Reel number.
// 3213 - 3214 Number of data traces per record.
Nx = unpack_int16(header_buffer+3212, swap_endian);
// 3215 - 3216 Number of auxiliary traces per record.
// 3217 - 3218 Sample interval, microseconds, this file (reel).
// 3219 - 3220 Sample interval, microseconds, original field recording.
// 3221 - 3222 Number of samples per data trace, this file (reel).
Nz = unpack_int16(header_buffer+3220, swap_endian);
// 3223 - 3224 Number of samples per data trace, original field recording.
// 3225 - 3226 Data sample format code: 1 = 4-byte IBM floating-point
// 2 = 4-byte, two's complement integer
// 3 = 2-byte, two's complement integer
// 4 = 4-byte fixed-point with gain (obsolete)
// 5 = 4-byte IEEE floating-point
// 6 = Not currently used
// 7 = Not currently used
// 8 = 1-byte, two's complement integer
format_code = unpack_int16(header_buffer+3224, swap_endian);
if(format_code<1 || format_code>8) {
swap_endian = true;
format_code = unpack_int16(header_buffer+3224, swap_endian);
// Try again...
if(format_code<1 || format_code>8) {
std::cerr<<"ERROR: unsupported data sample format code "<<format_code<<std::endl;
return -1;
}
continue; // restart header read
}
// 3227 - 3228 CDP fold.
// 3229 - 3230 Trace sorting code: Trace sorting code (i.e. type of ensemble) :
// -1 = Other (should be explained in user Extended Textual File Header stanza
// 0 = Unknown
// 1 = As recorded (no sorting)
// 2 = CDP ensemble
// 3 = Single fold continuous profile
// 4 = Horizontally stacked
// 5 = Common source point
// 6 = Common receiver point
// 7 = Common offset point
// 8 = Common mid-point
// 9 = Common conversion point
// 3231 - 3232 Vertical sum code: 1 = no sum 2 = two sum ... N = N sum (N = 32,767)
// 3233 - 3234 Sweep frequency at start.
// 3235 - 3236 Sweep frequency at end.
// 3237 - 3238 Sweep length, ms.
// 3239 - 3240 Sweep type code: 1 = linear
// 2 = parabolic
// 3 = exponential
// 4 = other
// 3241 - 3242 Trace number of sweep channel.
// 3243 - 3244 Sweep trace taper length, ms, at start if tapered.
// 3245 - 3246 Sweep trace taper length, ms, at end.
// 3247 - 3248 Taper type: 1 = linear 2 = cos 3 = other
// 3249 - 3250 Correlated data traces: 1 = no 2 = yes
// 3251 - 3252 Binary gain recovered: 1 = yes 2 = no
// 3253 - 3254 Amplitude recovery method: 1 = none 2 = spherical divergence 3 = AGC 4 = other
// 3255 - 3256 Measurement system: 1 = meters 2 = feet
// 3257 - 3258 Impulse signal: 1 = Upward = negative number.
// 2 = Upward = positive number.
// 3259 - 3260 Vibratory polarity code - seismic signal lags pilot signal by: 1 = 337.5 - 22.5 degrees
// 2 = 22.5 - 67.5 degrees
// 3 = 67.5 - 112.5 degrees
// 4 = 112.5 - 157.5 degrees
// 5 = 157.5 - 202.5 degrees
// 6 = 202.5 - 247.5 degrees
// Set tracesize
tracesize = 240+4*Nz;
// Get number of traces.
ntraces = (filesize-3600)/tracesize;
Ny = ntraces/Nx;
break;
}
dim[0] = Nx;
dim[1] = Ny;
dim[2] = Nz;
int xysize=dim[0]*dim[1];
int zysize=dim[2]*dim[1];
array.resize(dim[0]*dim[1]*dim[2]);
if(format_code==1) {
char trace_buffer[tracesize];
float x0[2], x1[2], scale_xy;
for(int i=0; i<ntraces; i++) {
// See Trace header in http://www.seg.org/documents/10161/77915/seg_y_rev1.pdf
infile.read(trace_buffer, tracesize);
int ix = i%Nx;
int iy = i/Nx;
if(i==0) {
scale_xy = unpack_int16(trace_buffer+70, swap_endian);
if(scale_xy<0)
scale_xy = 1.0/fabs(scale_xy);
x0[0] = scale_xy*unpack_int32(trace_buffer+72, swap_endian);
x0[1] = scale_xy*unpack_int32(trace_buffer+76, swap_endian);
} else if(i==1) {
x1[0] = scale_xy*unpack_int32(trace_buffer+72, swap_endian);
x1[1] = scale_xy*unpack_int32(trace_buffer+76, swap_endian);
float dx = std::max(fabs(x0[0]-x1[0]), fabs(x0[1]-x1[1]));
spacing[0] = dx;
spacing[1] = dx;
spacing[2] = scale_xy*unpack_int16(trace_buffer+116, swap_endian); // For model data this is overloaded as meters.
}
assert(unpack_int16(trace_buffer+114, swap_endian)==Nz);
#ifndef NDEBUG
if(i>0) {
int _ix = (scale_xy*unpack_int32(trace_buffer+72, swap_endian)-x0[0])/spacing[0] + 0.5; // +0.5 to protext against round-off
int _iy = (scale_xy*unpack_int32(trace_buffer+76, swap_endian)-x0[1])/spacing[1] + 0.5;
assert(ix==_ix);
assert(iy==_iy);
}
#endif
for(int iz=0; iz<Nz; iz++) {
char *next = trace_buffer+240+iz*4;
array[ix+iy*Nx+iz*xysize] = unpack_ibmfloat(next, swap_endian);
}
}
} else {
std::cerr<<"ERROR: format code "<<format_code<<" not yet supported"<<std::endl;
return -1;
}
return 0;
}
errcode_t profile_ser_internalize(const char *unused, profile_t *profilep,
unsigned char **bufpp, size_t *remainp)
{
errcode_t retval;
unsigned char *bp;
size_t remain;
int i;
prof_int32 fcount, tmp;
profile_filespec_t *flist = 0;
bp = *bufpp;
remain = *remainp;
fcount = 0;
if (remain >= 12)
(void) unpack_int32(&tmp, &bp, &remain);
else
tmp = 0;
if (tmp != PROF_MAGIC_PROFILE) {
retval = EINVAL;
goto cleanup;
}
(void) unpack_int32(&fcount, &bp, &remain);
retval = ENOMEM;
flist = (profile_filespec_t *) malloc(sizeof(profile_filespec_t) * (size_t) (fcount + 1));
if (!flist)
goto cleanup;
memset(flist, 0, sizeof(char *) * (size_t) (fcount+1));
for (i=0; i<fcount; i++) {
if (!unpack_int32(&tmp, &bp, &remain)) {
flist[i] = (char *) malloc((size_t) (tmp+1));
if (!flist[i])
goto cleanup;
memcpy(flist[i], bp, (size_t) tmp);
flist[i][tmp] = '\0';
bp += tmp;
remain -= (size_t) tmp;
}
}
if (unpack_int32(&tmp, &bp, &remain) ||
(tmp != PROF_MAGIC_PROFILE)) {
retval = EINVAL;
goto cleanup;
}
if ((retval = profile_init((const_profile_filespec_t *) flist,
profilep)))
goto cleanup;
*bufpp = bp;
*remainp = remain;
cleanup:
if (flist) {
for (i=0; i<fcount; i++) {
if (flist[i])
free(flist[i]);
}
free(flist);
}
return(retval);
}
int unpack_item(tlv_type_t type, uint16_t id, void * inbuf, uint16_t length, tlv_t * outtlv)
{
uint32_t outsize = 0;
int ret = 0;
void * value = NULL;
message_t * newmsg = NULL;
if ((NULL == inbuf) || (NULL == outtlv)) {
return -1;
}
value = malloc(length);
if (NULL == value) {
return -1;
}
switch (type) {
case TLV_TYPE_INT8:
case TLV_TYPE_UINT8:
outsize = length;
ret = pack_int8((uint8_t *)inbuf, (uint8_t *)value, &outsize);
break;
case TLV_TYPE_INT16:
case TLV_TYPE_UINT16:
outsize = length;
ret = unpack_int16((uint16_t *)inbuf, (uint16_t *)value, &outsize);
break;
case TLV_TYPE_INT32:
case TLV_TYPE_UINT32:
outsize = length;
ret = unpack_int32((uint32_t *)inbuf, (uint32_t *)value, &outsize);
break;
case TLV_TYPE_BYTES:
outsize = length;
ret = pack_bytes(inbuf, length, value, &outsize);
break;
case TLV_TYPE_MSG:
newmsg = msg_unpack((uint8_t *)inbuf, length);
if (NULL == newmsg) {
ret = -1;
break;
}
free(value);
value = (void *)newmsg;
ret = 0;
break;
default:
ret = -1;
}
if (0 != ret) {
free(value);
goto exit;
}
outtlv->id = id;
outtlv->type = type;
outtlv->length = length;
outtlv->value = value;
exit:
return ret;
}