BOOL PULSEwriterPLS::open(const char* file_name, PULSEheader* header, U32 compress, U32 io_buffer_size)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: file name pointer is zero\n");
return FALSE;
}
pulse_file = fopen(file_name, "wb");
if (pulse_file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", file_name);
return FALSE;
}
if (setvbuf(pulse_file, NULL, _IOFBF, io_buffer_size) != 0)
{
fprintf(stderr, "WARNING: setvbuf() failed with buffer size %u\n", io_buffer_size);
}
ByteStreamOut* out;
if (IS_LITTLE_ENDIAN())
out = new ByteStreamOutFileLE(pulse_file);
else
out = new ByteStreamOutFileBE(pulse_file);
if (this->file_name) free(this->file_name);
this->file_name = strdup(file_name);
return open(out, header, compress);
}
BOOL LASreader::open(const char* file_name, U32 io_buffer_size)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: fine name pointer is zero\n");
return FALSE;
}
file = fopen(file_name, "rb");
if (file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", file_name);
return FALSE;
}
if (setvbuf(file, NULL, _IOFBF, io_buffer_size) != 0)
{
fprintf(stderr, "WARNING: setvbuf() failed with buffer size %u\n", io_buffer_size);
}
// create input
ByteStreamIn* in;
if (IS_LITTLE_ENDIAN())
in = new ByteStreamInFileLE(file);
else
in = new ByteStreamInFileBE(file);
return open(in);
}
BOOL LASreaderQFIT::reopen(const char* file_name)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: fine name pointer is zero\n");
return FALSE;
}
// open file
file = fopen(file_name, "rb");
if (file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", file_name);
return FALSE;
}
// create input stream
if (IS_LITTLE_ENDIAN())
stream = new ByteStreamInFileLE(file);
else
stream = new ByteStreamInFileBE(file);
p_count = 0;
return stream->seek(offset);
}
BOOL LASwriterBIN::open(const char* file_name, const LASheader* header, const char* version, U32 io_buffer_size)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: file name pointer is zero\n");
return FALSE;
}
file = fopen(file_name, "wb");
if (file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", file_name);
return FALSE;
}
if (setvbuf(file, NULL, _IOFBF, io_buffer_size) != 0)
{
fprintf(stderr, "WARNING: setvbuf() failed with buffer size %u\n", io_buffer_size);
}
ByteStreamOut* out;
if (IS_LITTLE_ENDIAN())
out = new ByteStreamOutFileLE(file);
else
out = new ByteStreamOutFileBE(file);
return open(out, header, version);
}
BOOL LASwriterLAS::open(FILE* file, const LASheader* header, U32 compressor, I32 requested_version, I32 chunk_size)
{
if (file == 0)
{
fprintf(stderr,"ERROR: file pointer is zero\n");
return FALSE;
}
#ifdef _WIN32
if (file == stdout)
{
if(_setmode( _fileno( stdout ), _O_BINARY ) == -1 )
{
fprintf(stderr, "ERROR: cannot set stdout to binary (untranslated) mode\n");
}
}
#endif
ByteStreamOut* out;
if (IS_LITTLE_ENDIAN())
out = new ByteStreamOutFileLE(file);
else
out = new ByteStreamOutFileBE(file);
return open(out, header, compressor, requested_version, chunk_size);
}
BOOL LASreader::open(FILE* file)
{
if (file == 0)
{
fprintf(stderr,"ERROR: file pointer is zero\n");
return FALSE;
}
#ifdef _WIN32
if (file == stdin)
{
if(_setmode( _fileno( stdin ), _O_BINARY ) == -1 )
{
fprintf(stderr, "ERROR: cannot set stdin to binary (untranslated) mode\n");
return FALSE;
}
}
#endif
// create input
ByteStreamIn* in;
if (IS_LITTLE_ENDIAN())
in = new ByteStreamInFileLE(file);
else
in = new ByteStreamInFileBE(file);
return open(in);
}
BOOL PULSEwriterPLS::open(FILE* file, PULSEheader* header, U32 compress)
{
if (file == 0)
{
fprintf(stderr,"ERROR: file pointer is zero\n");
return FALSE;
}
#ifdef _WIN32
if (file == stdout)
{
if(_setmode( _fileno( stdout ), _O_BINARY ) == -1 )
{
fprintf(stderr, "ERROR: cannot set stdout to binary (untranslated) mode\n");
}
}
#endif
ByteStreamOut* out;
if (IS_LITTLE_ENDIAN())
out = new ByteStreamOutFileLE(file);
else
out = new ByteStreamOutFileBE(file);
return open(out, header, compress);
}
static Value *
arch_get_shift16(cpu_t *cpu, Value *addr, BasicBlock *bb)
{
Value *shift = AND(LSHR(addr,CONST(1)),CONST(1));
if (!IS_LITTLE_ENDIAN(cpu))
shift = XOR(shift, CONST(1));
return SHL(shift, CONST(4));
}
BOOL PULSEreaderGCW::open_waves()
{
if (file_name == 0)
{
return FALSE;
}
CHAR* temp_file_name = strdup(file_name);
I32 len = strlen(temp_file_name);
temp_file_name[len-3] = 'l';
temp_file_name[len-2] = 'w';
temp_file_name[len-1] = 'f';
if (waves_file)
{
fclose(waves_file);
}
waves_file = fopen(temp_file_name, "rb");
if (waves_file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", temp_file_name);
free(temp_file_name);
return FALSE;
}
free(temp_file_name);
if (waves_stream)
{
delete waves_stream;
}
if (IS_LITTLE_ENDIAN())
waves_stream = new ByteStreamInFileLE(waves_file);
else
waves_stream = new ByteStreamInFileBE(waves_file);
if (waves_stream == 0)
{
fprintf(stderr,"ERROR: waves_stream is zero\n");
return FALSE;
}
if (!waves8bit.init(header.get_descriptor(GCW_PULSE_DESCRIPTOR_INDEX_8_BIT)))
{
fprintf(stderr,"ERROR: cannot init waves8bit\n");
return FALSE;
}
if (!waves16bit.init(header.get_descriptor(GCW_PULSE_DESCRIPTOR_INDEX_16_BIT)))
{
fprintf(stderr,"ERROR: cannot init waves16bit\n");
return FALSE;
}
return TRUE;
}
BOOL LASwriterLAS::open(ostream& stream, const LASheader* header, U32 compressor, I32 requested_version, I32 chunk_size)
{
ByteStreamOut* out;
if (IS_LITTLE_ENDIAN())
out = new ByteStreamOutOstreamLE(stream);
else
out = new ByteStreamOutOstreamBE(stream);
return open(out, header, compressor, requested_version, chunk_size);
}
BOOL PULSEwriterPLS::open(ostream& stream, PULSEheader* header, U32 compress)
{
ByteStreamOut* out;
if (IS_LITTLE_ENDIAN())
out = new ByteStreamOutOstreamLE(stream);
else
out = new ByteStreamOutOstreamBE(stream);
return open(out, header, compress);
}
BOOL LASreader::open(istream& stream)
{
// create input
ByteStreamIn* in;
if (IS_LITTLE_ENDIAN())
in = new ByteStreamInIstreamLE(stream);
else
in = new ByteStreamInIstreamBE(stream);
return open(in);
}
BOOL LASreaderBIN::open(const char* file_name)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: fine name pointer is zero\n");
return FALSE;
}
// open file
file = fopen(file_name, "rb");
if (file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", file_name);
return FALSE;
}
// create input stream
ByteStreamIn* in;
if (IS_LITTLE_ENDIAN())
in = new ByteStreamInFileLE(file);
else
in = new ByteStreamInFileBE(file);
// clean header
header.clean();
// maybe set creation date
#ifdef _WIN32
WIN32_FILE_ATTRIBUTE_DATA attr;
SYSTEMTIME creation;
GetFileAttributesEx(file_name, GetFileExInfoStandard, &attr);
FileTimeToSystemTime(&attr.ftCreationTime, &creation);
int startday[13] = {-1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
header.file_creation_day = startday[creation.wMonth] + creation.wDay;
header.file_creation_year = creation.wYear;
// leap year handling
if ((((creation.wYear)%4) == 0) && (creation.wMonth > 2)) header.file_creation_day++;
#else
header.file_creation_day = 333;
header.file_creation_year = 2011;
#endif
return open(in);
}
bool LASunzipper::open(istream& instream, const LASzip* laszip)
{
if (!laszip) return return_error("const LASzip* laszip pointer is NULL");
count = 0;
if (reader) delete reader;
reader = new LASreadPoint();
if (!reader) return return_error("alloc of LASreadPoint failed");
if (!reader->setup(laszip->num_items, laszip->items, laszip)) return return_error("setup() of LASreadPoint failed");
if (stream) delete stream;
if (IS_LITTLE_ENDIAN())
stream = new ByteStreamInIstreamLE(instream);
else
stream = new ByteStreamInIstreamBE(instream);
if (!stream) return return_error("alloc of ByteStreamInStream failed");
if (!reader->init(stream)) return return_error("init() of LASreadPoint failed");
return true;
}
BOOL PULSEreaderGCW::open(const CHAR* file_name, U32 io_buffer_size)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: file name pointer is zero\n");
return FALSE;
}
if (pulse_file)
{
fclose(pulse_file);
}
pulse_file = fopen(file_name, "rb");
if (pulse_file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", file_name);
return FALSE;
}
if (setvbuf(pulse_file, NULL, _IOFBF, io_buffer_size) != 0)
{
fprintf(stderr, "WARNING: setvbuf() failed with buffer size %u\n", io_buffer_size);
}
if (pulse_stream)
{
delete pulse_stream;
}
if (IS_LITTLE_ENDIAN())
pulse_stream = new ByteStreamInFileLE(pulse_file);
else
pulse_stream = new ByteStreamInFileBE(pulse_file);
if (pulse_stream == 0)
{
fprintf(stderr,"ERROR: pulse_stream is zero\n");
return FALSE;
}
if (this->file_name) free(this->file_name);
this->file_name = strdup(file_name);
return open();
}
UINT FDKfread_EL(void *dst, INT size, UINT nmemb, FDKFILE *fp) {
UINT n, s0, s1, err;
UCHAR tmp, *ptr;
UCHAR tmp24[3];
/* Enforce alignment of 24 bit data. */
if (size == 3) {
ptr = (UCHAR*)dst;
err = 0;
for (n=0; n<nmemb; n++) {
if ((err = FDKfread(tmp24, 1, 3, fp)) != 3) {
return err;
}
*ptr++ = tmp24[0];
*ptr++ = tmp24[1];
*ptr++ = tmp24[2];
/* Sign extension */
if (tmp24[2] & 0x80) {
*ptr++ = 0xff;
} else {
*ptr++ = 0;
}
}
err = nmemb;
size = sizeof(LONG);
} else {
if ((err = FDKfread(dst, size, nmemb, fp)) != nmemb) {
return err;
}
}
if (!IS_LITTLE_ENDIAN() && size > 1) {
ptr = (UCHAR*)dst;
for (n=0; n<nmemb; n++) {
for (s0=0, s1=size-1; s0 < s1; s0++, s1--) {
tmp = ptr[s0];
ptr[s0] = ptr[s1];
ptr[s1] = tmp;
}
ptr += size;
}
}
return err;
}
UINT FDKfwrite_EL(void *ptrf, INT size, UINT nmemb, FDKFILE *fp) {
if (IS_LITTLE_ENDIAN()) {
FDKfwrite(ptrf, size, nmemb, fp);
} else {
UINT n;
INT s;
UCHAR *ptr = (UCHAR*) ptrf;
for (n=0; n<nmemb; n++) {
for (s=size-1; s>=0; s--) {
//FDKprintf("char = %c\n", (char)*(ptr+s));
FDKfwrite(ptr + s, 1, 1, fp);
}
ptr = ptr + size;
}
}
return nmemb;
}
BOOL LASwritePoint::setup(const U32 num_items, const LASitem* items, const LASzip* laszip)
{
U32 i;
// is laszip exists then we must use its items
if (laszip)
{
if (num_items != laszip->num_items) return FALSE;
if (items != laszip->items) return FALSE;
}
// create entropy encoder (if requested)
enc = 0;
if (laszip && laszip->compressor)
{
switch (laszip->coder)
{
case LASZIP_CODER_ARITHMETIC:
enc = new ArithmeticEncoder();
break;
default:
// entropy decoder not supported
return FALSE;
}
}
// initizalize the writers
writers = 0;
num_writers = num_items;
// disable chunking
chunk_size = U32_MAX;
// always create the raw writers
writers_raw = new LASwriteItem*[num_writers];
memset(writers_raw, 0, num_writers*sizeof(LASwriteItem*));
for (i = 0; i < num_writers; i++)
{
switch (items[i].type)
{
case LASitem::POINT10:
if (IS_LITTLE_ENDIAN())
writers_raw[i] = new LASwriteItemRaw_POINT10_LE();
else
writers_raw[i] = new LASwriteItemRaw_POINT10_BE();
break;
case LASitem::GPSTIME11:
if (IS_LITTLE_ENDIAN())
writers_raw[i] = new LASwriteItemRaw_GPSTIME11_LE();
else
writers_raw[i] = new LASwriteItemRaw_GPSTIME11_BE();
break;
case LASitem::RGB12:
if (IS_LITTLE_ENDIAN())
writers_raw[i] = new LASwriteItemRaw_RGB12_LE();
else
writers_raw[i] = new LASwriteItemRaw_RGB12_BE();
break;
case LASitem::WAVEPACKET13:
if (IS_LITTLE_ENDIAN())
writers_raw[i] = new LASwriteItemRaw_WAVEPACKET13_LE();
else
writers_raw[i] = new LASwriteItemRaw_WAVEPACKET13_BE();
break;
case LASitem::BYTE:
writers_raw[i] = new LASwriteItemRaw_BYTE(items[i].size);
break;
case LASitem::POINT14:
if (IS_LITTLE_ENDIAN())
writers_raw[i] = new LASwriteItemRaw_POINT14_LE();
else
return FALSE;
break;
case LASitem::RGBNIR14:
if (IS_LITTLE_ENDIAN())
writers_raw[i] = new LASwriteItemRaw_RGBNIR14_LE();
else
writers_raw[i] = new LASwriteItemRaw_RGBNIR14_BE();
break;
default:
return FALSE;
}
}
// if needed create the compressed writers and set versions
if (enc)
{
writers_compressed = new LASwriteItem*[num_writers];
memset(writers_compressed, 0, num_writers*sizeof(LASwriteItem*));
for (i = 0; i < num_writers; i++)
{
switch (items[i].type)
{
case LASitem::POINT10:
if (items[i].version == 1)
writers_compressed[i] = new LASwriteItemCompressed_POINT10_v1(enc);
else if (items[i].version == 2)
writers_compressed[i] = new LASwriteItemCompressed_POINT10_v2(enc);
else
return FALSE;
break;
case LASitem::GPSTIME11:
if (items[i].version == 1)
writers_compressed[i] = new LASwriteItemCompressed_GPSTIME11_v1(enc);
else if (items[i].version == 2)
writers_compressed[i] = new LASwriteItemCompressed_GPSTIME11_v2(enc);
else
return FALSE;
break;
case LASitem::RGB12:
if (items[i].version == 1)
writers_compressed[i] = new LASwriteItemCompressed_RGB12_v1(enc);
else if (items[i].version == 2)
writers_compressed[i] = new LASwriteItemCompressed_RGB12_v2(enc);
else
return FALSE;
break;
case LASitem::WAVEPACKET13:
if (items[i].version == 1)
writers_compressed[i] = new LASwriteItemCompressed_WAVEPACKET13_v1(enc);
else
return FALSE;
break;
case LASitem::BYTE:
if (items[i].version == 1)
writers_compressed[i] = new LASwriteItemCompressed_BYTE_v1(enc, items[i].size);
else if (items[i].version == 2)
writers_compressed[i] = new LASwriteItemCompressed_BYTE_v2(enc, items[i].size);
else
return FALSE;
break;
default:
return FALSE;
}
}
if (laszip->compressor == LASZIP_COMPRESSOR_POINTWISE_CHUNKED)
{
if (laszip->chunk_size) chunk_size = laszip->chunk_size;
chunk_count = 0;
number_chunks = U32_MAX;
}
}
return TRUE;
}
cpu_t *
cpu_new(cpu_arch_t arch, uint32_t flags, uint32_t arch_flags)
{
cpu_t *cpu;
llvm::InitializeNativeTarget();
cpu = new cpu_t;
assert(cpu != NULL);
memset(&cpu->info, 0, sizeof(cpu->info));
memset(&cpu->rf, 0, sizeof(cpu->rf));
cpu->info.type = arch;
cpu->info.name = "noname";
cpu->info.common_flags = flags;
cpu->info.arch_flags = arch_flags;
switch (arch) {
case CPU_ARCH_6502:
cpu->f = arch_func_6502;
break;
case CPU_ARCH_M68K:
cpu->f = arch_func_m68k;
break;
case CPU_ARCH_MIPS:
cpu->f = arch_func_mips;
break;
case CPU_ARCH_M88K:
cpu->f = arch_func_m88k;
break;
case CPU_ARCH_ARM:
cpu->f = arch_func_arm;
break;
case CPU_ARCH_8086:
cpu->f = arch_func_8086;
break;
case CPU_ARCH_FAPRA:
cpu->f = arch_func_fapra;
break;
default:
printf("illegal arch: %d\n", arch);
exit(1);
}
cpu->code_start = 0;
cpu->code_end = 0;
cpu->code_entry = 0;
cpu->tag = NULL;
uint32_t i;
for (i = 0; i < sizeof(cpu->func)/sizeof(*cpu->func); i++)
cpu->func[i] = NULL;
for (i = 0; i < sizeof(cpu->fp)/sizeof(*cpu->fp); i++)
cpu->fp[i] = NULL;
cpu->functions = 0;
cpu->flags_codegen = CPU_CODEGEN_OPTIMIZE;
cpu->flags_debug = CPU_DEBUG_NONE;
cpu->flags_hint = CPU_HINT_NONE;
cpu->flags = 0;
// init the frontend
cpu->f.init(cpu, &cpu->info, &cpu->rf);
assert(is_valid_gpr_size(cpu->info.register_size[CPU_REG_GPR]) &&
"the specified GPR size is not guaranteed to work");
assert(is_valid_fpr_size(cpu->info.register_size[CPU_REG_FPR]) &&
"the specified FPR size is not guaranteed to work");
assert(is_valid_vr_size(cpu->info.register_size[CPU_REG_VR]) &&
"the specified VR size is not guaranteed to work");
assert(is_valid_gpr_size(cpu->info.register_size[CPU_REG_XR]) &&
"the specified XR size is not guaranteed to work");
uint32_t count = cpu->info.register_count[CPU_REG_GPR];
if (count != 0) {
cpu->ptr_gpr = (Value **)calloc(count, sizeof(Value *));
cpu->in_ptr_gpr = (Value **)calloc(count, sizeof(Value *));
} else {
cpu->ptr_gpr = NULL;
cpu->in_ptr_gpr = NULL;
}
count = cpu->info.register_count[CPU_REG_XR];
if (count != 0) {
cpu->ptr_xr = (Value **)calloc(count, sizeof(Value *));
cpu->in_ptr_xr = (Value **)calloc(count, sizeof(Value *));
} else {
cpu->ptr_xr = NULL;
cpu->in_ptr_xr = NULL;
}
count = cpu->info.register_count[CPU_REG_FPR];
if (count != 0) {
cpu->ptr_fpr = (Value **)calloc(count, sizeof(Value *));
cpu->in_ptr_fpr = (Value **)calloc(count, sizeof(Value *));
} else {
cpu->ptr_fpr = NULL;
cpu->in_ptr_fpr = NULL;
}
if (cpu->info.psr_size != 0) {
cpu->ptr_FLAG = (Value **)calloc(cpu->info.flags_count,
sizeof(Value*));
assert(cpu->ptr_FLAG != NULL);
}
// init LLVM
cpu->mod = new Module(cpu->info.name, _CTX());
assert(cpu->mod != NULL);
cpu->exec_engine = ExecutionEngine::create(cpu->mod);
assert(cpu->exec_engine != NULL);
// check if FP80 and FP128 are supported by this architecture.
// XXX there is a better way to do this?
std::string data_layout = cpu->exec_engine->getDataLayout()->getStringRepresentation();
if (data_layout.find("f80") != std::string::npos) {
LOG("INFO: FP80 supported.\n");
cpu->flags |= CPU_FLAG_FP80;
}
if (data_layout.find("f128") != std::string::npos) {
LOG("INFO: FP128 supported.\n");
cpu->flags |= CPU_FLAG_FP128;
}
// check if we need to swap guest memory.
if (cpu->exec_engine->getDataLayout()->isLittleEndian()
^ IS_LITTLE_ENDIAN(cpu))
cpu->flags |= CPU_FLAG_SWAPMEM;
cpu->timer_total[TIMER_TAG] = 0;
cpu->timer_total[TIMER_FE] = 0;
cpu->timer_total[TIMER_BE] = 0;
cpu->timer_total[TIMER_RUN] = 0;
return cpu;
}
BOOL LASreadPoint::setup(U32 num_items, const LASitem* items, const LASzip* laszip)
{
U32 i;
// is laszip exists then we must use its items
if (laszip)
{
if (num_items == 0) return FALSE;
if (items == 0) return FALSE;
if (num_items != laszip->num_items) return FALSE;
if (items != laszip->items) return FALSE;
}
// delete old entropy decoder
if (dec)
{
delete dec;
dec = 0;
layered_las14_compression = FALSE;
}
// is the content compressed?
if (laszip && laszip->compressor)
{
// create new entropy decoder (if requested)
switch (laszip->coder)
{
case LASZIP_CODER_ARITHMETIC:
dec = new ArithmeticDecoder();
break;
default:
// entropy decoder not supported
return FALSE;
}
// maybe layered compression for LAS 1.4
layered_las14_compression = (laszip->compressor == LASZIP_COMPRESSOR_LAYERED_CHUNKED);
}
// initizalize the readers
readers = 0;
num_readers = num_items;
// disable chunking
chunk_size = U32_MAX;
// always create the raw readers
readers_raw = new LASreadItem*[num_readers];
for (i = 0; i < num_readers; i++)
{
switch (items[i].type)
{
case LASitem::POINT10:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_POINT10_LE();
else
readers_raw[i] = new LASreadItemRaw_POINT10_BE();
break;
case LASitem::GPSTIME11:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_GPSTIME11_LE();
else
readers_raw[i] = new LASreadItemRaw_GPSTIME11_BE();
break;
case LASitem::RGB12:
case LASitem::RGB14:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_RGB12_LE();
else
readers_raw[i] = new LASreadItemRaw_RGB12_BE();
break;
case LASitem::BYTE:
case LASitem::BYTE14:
readers_raw[i] = new LASreadItemRaw_BYTE(items[i].size);
break;
case LASitem::POINT14:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_POINT14_LE();
else
readers_raw[i] = new LASreadItemRaw_POINT14_BE();
break;
case LASitem::RGBNIR14:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_RGBNIR14_LE();
else
readers_raw[i] = new LASreadItemRaw_RGBNIR14_BE();
break;
case LASitem::WAVEPACKET13:
case LASitem::WAVEPACKET14:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_WAVEPACKET13_LE();
else
readers_raw[i] = new LASreadItemRaw_WAVEPACKET13_BE();
break;
default:
return FALSE;
}
point_size += items[i].size;
}
if (dec)
{
readers_compressed = new LASreadItem*[num_readers];
// seeks with compressed data need a seek point
if (seek_point)
{
delete [] seek_point[0];
delete [] seek_point;
}
seek_point = new U8*[num_items];
if (!seek_point) return FALSE;
if (layered_las14_compression)
{
// because combo LAS 1.0 - 1.4 point struct has padding
seek_point[0] = new U8[(point_size*2)];
// because extended_point_type must be set
seek_point[0][22] = 1;
}
else
{
seek_point[0] = new U8[point_size];
}
if (!seek_point[0]) return FALSE;
for (i = 0; i < num_readers; i++)
{
switch (items[i].type)
{
case LASitem::POINT10:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_POINT10_v1(dec);
else if (items[i].version == 2)
readers_compressed[i] = new LASreadItemCompressed_POINT10_v2(dec);
else
return FALSE;
break;
case LASitem::GPSTIME11:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_GPSTIME11_v1(dec);
else if (items[i].version == 2)
readers_compressed[i] = new LASreadItemCompressed_GPSTIME11_v2(dec);
else
return FALSE;
break;
case LASitem::RGB12:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_RGB12_v1(dec);
else if (items[i].version == 2)
readers_compressed[i] = new LASreadItemCompressed_RGB12_v2(dec);
else
return FALSE;
break;
case LASitem::BYTE:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_BYTE_v1(dec, items[i].size);
else if (items[i].version == 2)
readers_compressed[i] = new LASreadItemCompressed_BYTE_v2(dec, items[i].size);
else
return FALSE;
break;
case LASitem::POINT14:
if ((items[i].version == 3) || (items[i].version == 2)) // version == 2 from lasproto
readers_compressed[i] = new LASreadItemCompressed_POINT14_v3(dec, decompress_selective);
else if (items[i].version == 4)
readers_compressed[i] = new LASreadItemCompressed_POINT14_v4(dec, decompress_selective);
else
return FALSE;
break;
case LASitem::RGB14:
if ((items[i].version == 3) || (items[i].version == 2)) // version == 2 from lasproto
readers_compressed[i] = new LASreadItemCompressed_RGB14_v3(dec, decompress_selective);
else if (items[i].version == 4)
readers_compressed[i] = new LASreadItemCompressed_RGB14_v4(dec, decompress_selective);
else
return FALSE;
break;
case LASitem::RGBNIR14:
if ((items[i].version == 3) || (items[i].version == 2)) // version == 2 from lasproto
readers_compressed[i] = new LASreadItemCompressed_RGBNIR14_v3(dec, decompress_selective);
else if (items[i].version == 4)
readers_compressed[i] = new LASreadItemCompressed_RGBNIR14_v4(dec, decompress_selective);
else
return FALSE;
break;
case LASitem::BYTE14:
if ((items[i].version == 3) || (items[i].version == 2)) // version == 2 from lasproto
readers_compressed[i] = new LASreadItemCompressed_BYTE14_v3(dec, items[i].size, decompress_selective);
else if (items[i].version == 4)
readers_compressed[i] = new LASreadItemCompressed_BYTE14_v4(dec, items[i].size, decompress_selective);
else
return FALSE;
break;
case LASitem::WAVEPACKET13:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_WAVEPACKET13_v1(dec);
else
return FALSE;
break;
case LASitem::WAVEPACKET14:
if (items[i].version == 3)
readers_compressed[i] = new LASreadItemCompressed_WAVEPACKET14_v3(dec, decompress_selective);
else if (items[i].version == 4)
readers_compressed[i] = new LASreadItemCompressed_WAVEPACKET14_v4(dec, decompress_selective);
else
return FALSE;
break;
default:
return FALSE;
}
if (i)
{
if (layered_las14_compression)
{
// because combo LAS 1.0 - 1.4 point struct has padding
seek_point[i] = seek_point[i-1]+(2*items[i-1].size);
}
else
{
seek_point[i] = seek_point[i-1]+items[i-1].size;
}
}
}
if (laszip->compressor != LASZIP_COMPRESSOR_POINTWISE)
{
if (laszip->chunk_size) chunk_size = laszip->chunk_size;
number_chunks = U32_MAX;
}
}
return TRUE;
}
BOOL LASwaveform13writer::open(const char* file_name, const LASvlr_wave_packet_descr * const * wave_packet_descr)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: file name pointer is zero\n");
return FALSE;
}
if (wave_packet_descr == 0)
{
fprintf(stderr,"ERROR: wave packet descriptor pointer is zero\n");
return FALSE;
}
// copy relevant wave packet descriptions and check if compressed or not
U16 i, number = 0;
BOOL compressed = FALSE;
if (waveforms == 0)
{
waveforms = new LASwaveformDescription*[256];
for (i = 0; i < 256; i++) waveforms[i] = 0;
}
for (i = 0; i < 256; i++)
{
if (wave_packet_descr[i])
{
if (waveforms[i] == 0)
{
waveforms[i] = new LASwaveformDescription;
}
waveforms[i]->compression = wave_packet_descr[i]->getCompressionType();
waveforms[i]->nbits = wave_packet_descr[i]->getBitsPerSample();
waveforms[i]->nsamples = wave_packet_descr[i]->getNumberOfSamples();
compressed = compressed || (waveforms[i]->compression > 0);
number++;
}
else
{
if (waveforms[i])
{
delete waveforms[i];
waveforms[i] = 0;
}
}
}
// create file name and open file
char* file_name_temp = strdup(file_name);
int len = strlen(file_name_temp);
if (file_name_temp[len-3] == 'L' || file_name_temp[len-3] == 'W')
{
file_name_temp[len-3] = 'W';
file_name_temp[len-2] = 'D';
file_name_temp[len-1] = (compressed ? 'Z' : 'P');
}
else
{
file_name_temp[len-3] = 'w';
file_name_temp[len-2] = 'd';
file_name_temp[len-1] = (compressed ? 'z' : 'p');
}
file = fopen(file_name_temp, "wb");
if (file == 0)
{
fprintf(stderr, "ERROR: cannot open waveform file '%s'\n", file_name_temp);
free(file_name_temp);
return FALSE;
}
free(file_name_temp);
// create strea,
if (IS_LITTLE_ENDIAN())
{
stream = new ByteStreamOutFileLE(file);
}
else
{
stream = new ByteStreamOutFileBE(file);
}
// write extended variable length header variable after variable (to avoid alignment issues)
U16 reserved = 0xAABB;
if (!stream->put16bitsLE((U8*)&reserved))
{
fprintf(stderr,"ERROR: writing EVLR reserved\n");
return FALSE;
}
I8 user_id[16];
memset(user_id, 0, 16);
strcpy(user_id, "LASF_Spec");
if (!stream->putBytes((U8*)user_id, 16))
{
fprintf(stderr,"ERROR: writing EVLR user_id\n");
return FALSE;
}
U16 record_id = 65535;
if (!stream->put16bitsLE((U8*)&record_id))
{
fprintf(stderr,"ERROR: writing EVLR record_id\n");
return FALSE;
}
I64 record_length_after_header = 0;
if (!stream->put64bitsLE((U8*)&record_length_after_header))
{
fprintf(stderr,"ERROR: writing EVLR record_length_after_header\n");
return FALSE;
}
I8 description[32];
memset(description, 0, 32);
sprintf(description, "%s by LAStools (%d)", (compressed ? "compressed" : "created"), LAS_TOOLS_VERSION);
if (!stream->putBytes((U8*)description, 32))
{
fprintf(stderr,"ERROR: writing EVLR description\n");
return FALSE;
}
// write waveform descriptor cross-check
char magic[25];
sprintf(magic, "LAStools waveform %d", LAS_TOOLS_VERSION);
if (!stream->putBytes((U8*)magic, 24))
{
fprintf(stderr,"ERROR: writing waveform descriptor cross-check\n");
return FALSE;
}
if (!stream->put16bitsLE((U8*)&number))
{
fprintf(stderr,"ERROR: writing number of waveform descriptors\n");
return FALSE;
}
for (i = 0; i < 256; i++)
{
if (waveforms[i])
{
if (!stream->put16bitsLE((U8*)&i))
{
fprintf(stderr,"ERROR: writing index of waveform descriptor %d\n", i);
return FALSE;
}
if (!stream->putByte(waveforms[i]->compression))
{
fprintf(stderr,"ERROR: writing compression of waveform descriptor %d\n", i);
return FALSE;
}
if (!stream->putByte(waveforms[i]->nbits))
{
fprintf(stderr,"ERROR: writing nbits of waveform descriptor %d\n", i);
return FALSE;
}
if (!stream->put16bitsLE((U8*)&(waveforms[i]->nsamples)))
{
fprintf(stderr,"ERROR: writing nsamples of waveform descriptor %d\n", i);
return FALSE;
}
}
}
// create compressor
if (compressed)
{
if (enc == 0) enc = new ArithmeticEncoder();
if (ic8 == 0) ic8 = new IntegerCompressor(enc, 8);
if (ic16 == 0) ic16 = new IntegerCompressor(enc, 16);
}
return TRUE;
}
/**
* @brief Create a new CPU core structure and initialize the llmv Module,ExectionEngine
*
* @param arch the architecture type of CPU core
* @param flags some flags,such as floating point,little/big endian
* @param arch_flags target machine bits
*
* @return pointer of CPU core structure
*/
cpu_t *
cpu_new(uint32_t flags, uint32_t arch_flags, arch_func_t arch_func)
{
cpu_t *cpu;
llvm::InitializeNativeTarget();
cpu = new cpu_t;
assert(cpu != NULL);
memset(&cpu->info, 0, sizeof(cpu->info));
memset(&cpu->rf, 0, sizeof(cpu->rf));
cpu->info.name = "noname";
cpu->info.common_flags = flags;
cpu->info.arch_flags = arch_flags;
cpu->f = arch_func;
cpu->icounter = 0;
cpu->dyncom_engine = new dyncom_engine_t;
cpu->dyncom_engine->code_start = 0;
cpu->dyncom_engine->code_end = 0;
cpu->dyncom_engine->code_entry = 0;
cpu->dyncom_engine->tag = NULL;
/* init hash fast map */
#ifdef HASH_FAST_MAP
cpu->dyncom_engine->fmap = (fast_map)malloc(sizeof(void*) * HASH_FAST_MAP_SIZE);
memset(cpu->dyncom_engine->fmap, 0, sizeof(addr_t) * HASH_FAST_MAP_SIZE);
#endif
uint32_t i;
for (i = 0; i < 4; i++) {
cpu->dyncom_engine->tag_array[i] = NULL;
cpu->dyncom_engine->code_size[i] = 0;
}
cpu->dyncom_engine->tag_table = (tag_t ***)malloc(TAG_LEVEL1_TABLE_SIZE * sizeof(tag_t **));
memset(cpu->dyncom_engine->tag_table, 0, TAG_LEVEL1_TABLE_SIZE * sizeof(tag_t **));
for (i = 0; i < sizeof(cpu->dyncom_engine->func)/sizeof(*cpu->dyncom_engine->func); i++)
cpu->dyncom_engine->func[i] = NULL;
for (i = 0; i < sizeof(cpu->dyncom_engine->fp)/sizeof(*cpu->dyncom_engine->fp); i++)
cpu->dyncom_engine->fp[i] = NULL;
cpu->dyncom_engine->functions = 0;
cpu->dyncom_engine->flags_codegen = CPU_CODEGEN_OPTIMIZE;
cpu->dyncom_engine->flags_debug = CPU_DEBUG_NONE;
cpu->dyncom_engine->flags_hint = CPU_HINT_NONE;
cpu->dyncom_engine->flags = 0;
// init the frontend
cpu->f.init(cpu, &cpu->info, &cpu->rf);
assert(is_valid_gpr_size(cpu->info.register_size[CPU_REG_GPR]) &&
"the specified GPR size is not guaranteed to work");
assert(is_valid_fpr_size(cpu->info.register_size[CPU_REG_FPR]) &&
"the specified FPR size is not guaranteed to work");
assert(is_valid_vr_size(cpu->info.register_size[CPU_REG_VR]) &&
"the specified VR size is not guaranteed to work");
assert(is_valid_gpr_size(cpu->info.register_size[CPU_REG_XR]) &&
"the specified XR size is not guaranteed to work");
uint32_t count = cpu->info.register_count[CPU_REG_GPR];
if (count != 0) {
cpu->ptr_gpr = (Value **)calloc(count, sizeof(Value *));
cpu->in_ptr_gpr = (Value **)calloc(count, sizeof(Value *));
} else {
cpu->ptr_gpr = NULL;
cpu->in_ptr_gpr = NULL;
}
count = cpu->info.register_count[CPU_REG_XR];
if (count != 0) {
cpu->ptr_xr = (Value **)calloc(count, sizeof(Value *));
cpu->in_ptr_xr = (Value **)calloc(count, sizeof(Value *));
} else {
cpu->ptr_xr = NULL;
cpu->in_ptr_xr = NULL;
}
count = cpu->info.register_count[CPU_REG_SPR];
if (count != 0) {
cpu->ptr_spr = (Value **)calloc(count, sizeof(Value *));
cpu->in_ptr_spr = (Value **)calloc(count, sizeof(Value *));
} else {
cpu->ptr_spr = NULL;
cpu->in_ptr_spr = NULL;
}
count = cpu->info.register_count[CPU_REG_FPR];
if (count != 0) {
cpu->ptr_fpr = (Value **)calloc(count, sizeof(Value *));
cpu->in_ptr_fpr = (Value **)calloc(count, sizeof(Value *));
} else {
cpu->ptr_fpr = NULL;
cpu->in_ptr_fpr = NULL;
}
if (cpu->info.psr_size != 0) {
cpu->ptr_FLAG = (Value **)calloc(cpu->info.flags_count,
sizeof(Value*));
assert(cpu->ptr_FLAG != NULL);
}
// init LLVM
cpu->dyncom_engine->mod = new Module(cpu->info.name, _CTX());
assert(cpu->dyncom_engine->mod != NULL);
cpu->dyncom_engine->exec_engine = ExecutionEngine::create(cpu->dyncom_engine->mod);
assert(cpu->dyncom_engine->exec_engine != NULL);
// check if FP80 and FP128 are supported by this architecture.
// XXX there is a better way to do this?
std::string data_layout = cpu->dyncom_engine->exec_engine->getTargetData()->getStringRepresentation();
if (data_layout.find("f80") != std::string::npos) {
LOG("INFO: FP80 supported.\n");
cpu->dyncom_engine->flags |= CPU_FLAG_FP80;
}
if (data_layout.find("f128") != std::string::npos) {
LOG("INFO: FP128 supported.\n");
cpu->dyncom_engine->flags |= CPU_FLAG_FP128;
}
// check if we need to swap guest memory.
if (cpu->dyncom_engine->exec_engine->getTargetData()->isLittleEndian()
^ IS_LITTLE_ENDIAN(cpu))
cpu->dyncom_engine->flags |= CPU_FLAG_SWAPMEM;
cpu->timer_total[TIMER_TAG] = 0;
cpu->timer_total[TIMER_FE] = 0;
cpu->timer_total[TIMER_BE] = 0;
cpu->timer_total[TIMER_RUN] = 0;
cpu->timer_total[TIMER_OPT] = 0;
debug_func_init(cpu);
syscall_func_init(cpu);
return cpu;
}
BOOL LASreaderQFIT::open(ByteStreamIn* stream)
{
U32 i;
if (stream == 0)
{
fprintf(stderr,"ERROR: ByteStreamIn* pointer is zero\n");
return FALSE;
}
this->stream = stream;
// read the QFIT header
try { stream->get32bitsLE((U8*)&version); } catch(...)
{
fprintf(stderr,"ERROR: reading QFIT header\n");
return FALSE;
}
// is QFIT file little-endian
if (version == 40 || version == 48 || version == 56)
{
little_endian = TRUE;
endian_swap = (IS_LITTLE_ENDIAN() == FALSE);
}
else
{
ENDIAN_SWAP_32((U8*)&version);
if (version == 40 || version == 48 || version == 56)
{
little_endian = FALSE;
endian_swap = (IS_LITTLE_ENDIAN() == TRUE);
}
else
{
fprintf(stderr,"ERROR: corrupt QFIT header.\n");
return FALSE;
}
}
// read version bytes until point start offset
try { stream->getBytes((U8*)buffer, version); } catch(...)
{
fprintf(stderr,"ERROR: reading %d bytes until point start offset from QFIT header\n", version);
return FALSE;
}
// read point start offset
try { if (little_endian) stream->get32bitsLE((U8*)&offset); else stream->get32bitsBE((U8*)&offset); } catch(...)
{
fprintf(stderr,"ERROR: reading point start offset from QFIT header\n");
return FALSE;
}
// seek to end of file find out number of points
stream->seekEnd();
npoints = (stream->tell() - offset) / version;
// seek back to start of points
stream->seek(offset);
// populate the header as much as possible
sprintf(header.system_identifier, "LAStools (c) by Martin Isenburg");
sprintf(header.generating_software, "via LASreaderQFIT (%d)", LAS_TOOLS_VERSION);
header.number_of_point_records = (U32)npoints;
header.number_of_points_by_return[0] = header.number_of_point_records;
header.extended_number_of_point_records = npoints;
header.extended_number_of_points_by_return[0] = npoints;
header.x_scale_factor = 0.000001;
header.y_scale_factor = 0.000001;
header.z_scale_factor = 0.001;
header.x_offset = 0;
header.y_offset = 0;
header.z_offset = 0;
try {
LASattribute scan_azimuth(LAS_ATTRIBUTE_I32, "scan azimuth", "Scan Azimuth (degrees X 1,000)");
scan_azimuth.set_scale(0.001);
scan_azimuth.set_min(0);
scan_azimuth.set_max(360000);
header.add_extra_attribute(scan_azimuth);
}
catch(...) {
fprintf(stderr,"ERROR: initializing attribute scan_azimuth\n");
return FALSE;
}
try {
LASattribute pitch(LAS_ATTRIBUTE_I32, "pitch", "Pitch (degrees X 1,000)");
pitch.set_scale(0.001);
pitch.set_min(-90000);
pitch.set_max(90000);
header.add_extra_attribute(pitch);
}
catch(...) {
fprintf(stderr,"ERROR: initializing attribute pitch\n");
return FALSE;
}
try {
LASattribute roll(LAS_ATTRIBUTE_I32, "roll", "Roll (degrees X 1,000)");
roll.set_scale(0.001);
roll.set_min(-90000);
roll.set_max(90000);
header.add_extra_attribute(roll);
}
catch(...) {
fprintf(stderr,"ERROR: initializing attribute roll\n");
return FALSE;
}
if (version == 48)
{
try {
LASattribute pulse_width(LAS_ATTRIBUTE_U8, "pulse width", "Pulse Width (digitizer samples)");
header.add_extra_attribute(pulse_width);
}
catch(...) {
fprintf(stderr,"ERROR: initializing attribute pulse width\n");
return FALSE;
}
}
header.update_extra_bytes_vlr();
// set point type
header.point_data_format = 1;
header.point_data_record_length = 28 + header.get_total_extra_attributes_size();
// initialize point
point.init(&header, header.point_data_format, header.point_data_record_length, &header);
// initialize extra attribute offsets
scan_azimuth_array_offset = point.attributer->get_extra_attribute_array_offset("scan azimuth");
pitch_array_offset = point.attributer->get_extra_attribute_array_offset("pitch");
roll_array_offset = point.attributer->get_extra_attribute_array_offset("roll");
if (version == 48)
{
pulse_width_array_offset = point.attributer->get_extra_attribute_array_offset("pulse width");
}
// set point count to zero
p_count = 0;
// approximate bounding box init
populated_header = FALSE;
if (!read_point()) return FALSE;
header.min_x = header.max_x = point.get_x();
header.min_y = header.max_y = point.get_y();
header.min_z = header.max_z = point.get_z();
for (i = header.number_of_point_records/50; i < header.number_of_point_records; i += header.number_of_point_records/50)
{
if (!seek(i)) return FALSE;
if (!read_point()) return FALSE;
}
return seek(0);
}
BOOL PULSEwriteWaves::write(const WAVESwaves* waves)
{
if (waves == 0)
{
fprintf(stderr,"ERROR: waves pointer is zero\n");
return FALSE;
}
// waves can potentially store additional bytes at the beginning of the waves data
if (waves->get_number_of_extra_bytes())
{
try { outstream->putBytes(waves->get_extra_bytes(), waves->get_number_of_extra_bytes()); } catch(...)
{
fprintf(stderr,"ERROR: writing %d extra waves bytes\n", waves->get_number_of_extra_bytes());
return FALSE;
}
}
// now loop over all samplings
I32 m, s, i;
WAVESsampling* sampling;
for (m = 0; m < waves->get_number_of_samplings(); m++)
{
sampling = waves->get_sampling(m);
// some samplings store a varying number of segments
if (sampling->get_bits_for_number_of_segments())
{
if (sampling->get_bits_for_number_of_segments() == 8)
{
U8 number_of_segments = (U8)(sampling->get_number_of_segments());
try { outstream->putByte(number_of_segments); } catch(...)
{
return FALSE;
}
}
else if (sampling->get_bits_for_number_of_segments() == 16)
{
U16 number_of_segments = (U16)(sampling->get_number_of_segments());
try { outstream->put16bitsLE((U8*)&number_of_segments); } catch(...)
{
return FALSE;
}
}
else
{
fprintf(stderr,"ERROR: %d bits_for_number_of_segments not supported\n", sampling->get_bits_for_number_of_segments());
return FALSE;
}
}
// loop over the segments
for (s = 0; s < sampling->get_number_of_segments(); s++)
{
// all subsequent calls to sampling will be in regards to segment s
sampling->set_active_segment(s);
// some samplings store a varying duration to the anchor per segment
if (sampling->get_bits_for_duration_from_anchor())
{
if (sampling->get_bits_for_duration_from_anchor() == 16)
{
I16 duration_from_anchor = (I16)(sampling->get_duration_from_anchor_for_segment());
try { outstream->put16bitsLE((U8*)&duration_from_anchor); } catch(...)
{
return FALSE;
}
}
else if (sampling->get_bits_for_duration_from_anchor() == 32)
{
I32 duration_from_anchor = (I32)(sampling->get_duration_from_anchor_for_segment());
try { outstream->put32bitsLE((U8*)&duration_from_anchor); } catch(...)
{
return FALSE;
}
}
else
{
fprintf(stderr,"ERROR: %d bits_for_duration_from_anchor not supported\n", sampling->get_bits_for_duration_from_anchor());
return FALSE;
}
}
// some samplings store a varying number of samples per segment
if (sampling->get_bits_for_number_of_samples())
{
if (sampling->get_bits_for_number_of_samples() == 8)
{
U8 number_of_samples = (U8)(sampling->get_number_of_samples_for_segment());
try { outstream->putByte(number_of_samples); } catch(...)
{
return FALSE;
}
}
else if (sampling->get_bits_for_number_of_samples() == 16)
{
U16 number_of_samples = (U16)(sampling->get_number_of_samples_for_segment());
try { outstream->put16bitsLE((U8*)&number_of_samples); } catch(...)
{
return FALSE;
}
}
else
{
fprintf(stderr,"ERROR: %d bits_for_number_of_samples not supported\n", sampling->get_bits_for_number_of_samples());
return FALSE;
}
}
I32 number_of_samples = sampling->get_number_of_samples_for_segment();
if (sampling->get_bits_per_sample() == 8)
{
const U8* samples = (const U8*)sampling->get_samples();
try { outstream->putBytes(samples, number_of_samples); } catch(...)
{
return FALSE;
}
}
else if (sampling->get_bits_per_sample() == 16)
{
if (IS_LITTLE_ENDIAN())
{
const U8* samples = (const U8*)sampling->get_samples();
try { outstream->putBytes(samples, 2*number_of_samples); } catch(...)
{
return FALSE;
}
}
else
{
const U16* samples = (const U16*)sampling->get_samples();
for (i = 0; i < number_of_samples; i++)
{
try { outstream->put16bitsLE((U8*)&(samples[i])); } catch(...)
{
return FALSE;
}
}
}
}
else
{
fprintf(stderr,"ERROR: %d bits_per_sample not supported\n", sampling->get_bits_per_sample());
return FALSE;
}
}
}
return TRUE;
}
BOOL LASreaderQFIT::open(const char* file_name)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: fine name pointer is zero\n");
return FALSE;
}
// open file
file = fopen(file_name, "rb");
if (file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", file_name);
return FALSE;
}
// create input stream
ByteStreamIn* in;
if (IS_LITTLE_ENDIAN())
in = new ByteStreamInFileLE(file);
else
in = new ByteStreamInFileBE(file);
// clean the header
header.clean();
// set projection
LASvlr_key_entry geo_keys[4];
// projected coordinates
geo_keys[0].key_id = 1024; // GTModelTypeGeoKey
geo_keys[0].tiff_tag_location = 0;
geo_keys[0].count = 1;
geo_keys[0].value_offset = 2; // ModelTypeGeographic
// ellipsoid used with latitude/longitude coordinates
geo_keys[1].key_id = 2048; // GeographicTypeGeoKey
geo_keys[1].tiff_tag_location = 0;
geo_keys[1].count = 1;
geo_keys[1].value_offset = 4326; // GCS_WGS_84
// vertical units
geo_keys[2].key_id = 4099; // VerticalUnitsGeoKey
geo_keys[2].tiff_tag_location = 0;
geo_keys[2].count = 1;
geo_keys[2].value_offset = 9001; // meter
// vertical datum
geo_keys[3].key_id = 4096; // VerticalCSTypeGeoKey
geo_keys[3].tiff_tag_location = 0;
geo_keys[3].count = 1;
geo_keys[3].value_offset = 5030; // VertCS_WGS_84_ellipsoid
header.set_geo_keys(4, geo_keys);
// maybe set creation date
#ifdef _WIN32
WIN32_FILE_ATTRIBUTE_DATA attr;
SYSTEMTIME creation;
GetFileAttributesEx(file_name, GetFileExInfoStandard, &attr);
FileTimeToSystemTime(&attr.ftCreationTime, &creation);
int startday[13] = {-1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
header.file_creation_day = startday[creation.wMonth] + creation.wDay;
header.file_creation_year = creation.wYear;
// leap year handling
if ((((creation.wYear)%4) == 0) && (creation.wMonth > 2)) header.file_creation_day++;
#else
header.file_creation_day = 333;
header.file_creation_year = 2011;
#endif
return open(in);
}
BOOL PULSEwriterPLS::open_waves()
{
if (file_name == 0)
{
return FALSE;
}
CHAR* temp_file_name = strdup(file_name);
I32 len = strlen(temp_file_name);
temp_file_name[len-3] = 'w';
temp_file_name[len-2] = 'v';
temp_file_name[len-1] = (compress ? 'z' : 's');
if (waves_file)
{
fclose(waves_file);
}
waves_file = fopen(temp_file_name, "wb");
if (waves_file == 0)
{
fprintf(stderr, "ERROR: cannot open file '%s'\n", temp_file_name);
free(temp_file_name);
return FALSE;
}
free(temp_file_name);
if (waves_stream)
{
delete waves_stream;
}
if (IS_LITTLE_ENDIAN())
waves_stream = new ByteStreamOutFileLE(waves_file);
else
waves_stream = new ByteStreamOutFileBE(waves_file);
if (waves_stream == 0)
{
fprintf(stderr,"ERROR: allocating waves_stream\n");
return FALSE;
}
WAVESheader waves_header;
if (compress)
{
waves_header.compression = 1;
}
else
{
waves_header.compression = 0;
}
if (!waves_header.save(waves_stream))
{
fprintf(stderr,"ERROR: saving WAVESheader\n");
return FALSE;
}
if (compress)
{
waves_writer = new PULSEwriteWaves_compressed();
}
else
{
waves_writer = new PULSEwriteWaves_raw();
}
if (waves_writer == 0)
{
fprintf(stderr,"ERROR: allocating waves_writer\n");
return FALSE;
}
if (!waves_writer->init(waves_stream))
{
fprintf(stderr,"ERROR: initializing waves_writer\n");
return FALSE;
}
return TRUE;
}
BOOL PULSEreadWaves_raw::read(WAVESwaves* waves)
{
if (waves == 0)
{
fprintf(stderr,"ERROR: waves pointer is zero\n");
return FALSE;
}
// waves can potentially store additional bytes at the beginning of the waves data
if (waves->get_number_of_extra_bytes())
{
try { instream->getBytes(waves->get_extra_bytes(), waves->get_number_of_extra_bytes()); } catch(...)
{
fprintf(stderr,"ERROR: reading %d extra waves bytes\n", waves->get_number_of_extra_bytes());
return FALSE;
}
}
// now loop over all samplings
I32 m, s, i;
WAVESsampling* sampling;
for (m = 0; m < waves->get_number_of_samplings(); m++)
{
sampling = waves->get_sampling(m);
// some samplings store a varying number of segments
if (sampling->get_bits_for_number_of_segments())
{
if (sampling->get_bits_for_number_of_segments() == 8)
{
U8 number_of_segments;
try { number_of_segments = instream->getByte(); } catch(...)
{
fprintf(stderr,"ERROR: cannot read byte for number_of_segments in sampling %d\n", m);
return FALSE;
}
if (!sampling->set_number_of_segments(number_of_segments))
{
fprintf(stderr,"ERROR: cannot set number_of_segments %d for sampling %d\n", number_of_segments, m);
return FALSE;
}
}
else if (sampling->get_bits_for_number_of_segments() == 16)
{
U16 number_of_segments;
try { instream->get16bitsLE((U8*)&number_of_segments); } catch(...)
{
fprintf(stderr,"ERROR: cannot read word for number_of_segments in sampling %d\n", m);
return FALSE;
}
if (!sampling->set_number_of_segments(number_of_segments))
{
fprintf(stderr,"ERROR: cannot set number_of_segments %d for sampling %d\n", number_of_segments, m);
return FALSE;
}
}
else
{
fprintf(stderr,"ERROR: %d bits_for_number_of_segments not supported\n", sampling->get_bits_for_number_of_segments());
return FALSE;
}
}
// loop over the segments
for (s = 0; s < sampling->get_number_of_segments(); s++)
{
// all subsequent calls to sampling will be in regards to segment s
sampling->set_active_segment(s);
// some samplings store a varying duration to the anchor per segment
if (sampling->get_bits_for_duration_from_anchor())
{
if (sampling->get_bits_for_duration_from_anchor() == 16)
{
I16 duration_from_anchor;
try { instream->get16bitsLE((U8*)&duration_from_anchor); } catch(...)
{
fprintf(stderr,"ERROR: cannot read word for duration_from_anchor of segment %d in sampling %d\n", s, m);
return FALSE;
}
if (!sampling->set_quantized_duration_from_anchor_for_segment(duration_from_anchor))
{
fprintf(stderr,"ERROR: cannot set duration_from_anchor %d of segment %d in sampling %d\n", duration_from_anchor, s, m);
return FALSE;
}
}
else if (sampling->get_bits_for_duration_from_anchor() == 32)
{
I32 duration_from_anchor;
try { instream->get32bitsLE((U8*)&duration_from_anchor); } catch(...)
{
fprintf(stderr,"ERROR: cannot read doubleword for duration_from_anchor of segment %d in sampling %d\n", s, m);
return FALSE;
}
if (!sampling->set_quantized_duration_from_anchor_for_segment(duration_from_anchor))
{
fprintf(stderr,"ERROR: cannot set duration_from_anchor %d of segment %d in sampling %d\n", duration_from_anchor, s, m);
return FALSE;
}
}
else
{
fprintf(stderr,"ERROR: %d bits_for_duration_from_anchor not supported\n", sampling->get_bits_for_duration_from_anchor());
return FALSE;
}
}
// some samplings store a varying number of samples per segment
if (sampling->get_bits_for_number_of_samples())
{
if (sampling->get_bits_for_number_of_samples() == 8)
{
U8 number_of_samples;
try { number_of_samples = instream->getByte(); } catch(...)
{
fprintf(stderr,"ERROR: cannot read byte for number_of_samples of segment %d in sampling %d\n", s, m);
return FALSE;
}
if (!sampling->set_number_of_samples_for_segment(number_of_samples))
{
fprintf(stderr,"ERROR: cannot set number_of_samples %d for segment %d in sampling %d\n", number_of_samples, s, m);
return FALSE;
}
}
else if (sampling->get_bits_for_number_of_samples() == 16)
{
U16 number_of_samples;
try { instream->get16bitsLE((U8*)&number_of_samples); } catch(...)
{
fprintf(stderr,"ERROR: cannot read word for number_of_samples of segment %d in sampling %d\n", s, m);
return FALSE;
}
if (!sampling->set_number_of_samples_for_segment(number_of_samples))
{
fprintf(stderr,"ERROR: cannot set number_of_samples %d for segment %d in sampling %d\n", number_of_samples, s, m);
return FALSE;
}
}
else
{
fprintf(stderr,"ERROR: %d bits_for_number_of_samples not supported\n", sampling->get_bits_for_number_of_samples());
return FALSE;
}
}
I32 number_of_samples = sampling->get_number_of_samples_for_segment();
if (sampling->get_bits_per_sample() == 8)
{
U8* samples = sampling->get_samples();
try { instream->getBytes(samples, number_of_samples); } catch(...)
{
return FALSE;
}
}
else if (sampling->get_bits_per_sample() == 16)
{
if (IS_LITTLE_ENDIAN())
{
U8* samples = sampling->get_samples();
try { instream->getBytes(samples, 2*number_of_samples); } catch(...)
{
return FALSE;
}
}
else
{
U16* samples = (U16*)sampling->get_samples();
for (i = 0; i < number_of_samples; i++)
{
try { instream->get16bitsLE((U8*)&(samples[i])); } catch(...)
{
return FALSE;
}
}
}
}
else
{
fprintf(stderr,"ERROR: %d bits_per_sample not supported\n", sampling->get_bits_per_sample());
return FALSE;
}
}
}
return TRUE;
}
BOOL LASwaveform13reader::open(const char* file_name, I64 start_of_waveform_data_packet_record, const LASvlr_wave_packet_descr * const * wave_packet_descr)
{
if (file_name == 0)
{
fprintf(stderr,"ERROR: file name pointer is zero\n");
return FALSE;
}
if (wave_packet_descr == 0)
{
fprintf(stderr,"ERROR: wave packet descriptor pointer is zero\n");
return FALSE;
}
// check if compressed or not
I32 i;
compressed = FALSE;
for (i = 0; i < 256; i++)
{
if (wave_packet_descr[i])
{
compressed = compressed || (wave_packet_descr[i]->getCompressionType() > 0);
}
}
// create file name and open file
if (start_of_waveform_data_packet_record == 0)
{
if (!compressed && (strstr(".wdp", file_name) || strstr(".WDP", file_name)))
{
file = fopen(file_name, "rb");
}
else if (compressed && (strstr(".wdz", file_name) || strstr(".WDZ", file_name)))
{
file = fopen(file_name, "rb");
}
else
{
char* file_name_temp = strdup(file_name);
int len = strlen(file_name_temp);
if ((file_name_temp[len-3] == 'L') || (file_name_temp[len-3] == 'W'))
{
file_name_temp[len-3] = 'W';
file_name_temp[len-2] = 'D';
file_name_temp[len-1] = (compressed ? 'Z' : 'P');
}
else
{
file_name_temp[len-3] = 'w';
file_name_temp[len-2] = 'd';
file_name_temp[len-1] = (compressed ? 'z' : 'p');
}
file = fopen(file_name_temp, "rb");
free(file_name_temp);
}
}
else
{
file = fopen(file_name, "rb");
}
if (file == 0)
{
fprintf(stderr, "ERROR: cannot open waveform file '%s'\n", file_name);
return FALSE;
}
if (IS_LITTLE_ENDIAN())
{
stream = new ByteStreamInFileLE(file);
}
else
{
stream = new ByteStreamInFileBE(file);
}
this->start_of_waveform_data_packet_record = start_of_waveform_data_packet_record;
this->wave_packet_descr = wave_packet_descr;
// attempt waveform descriptor cross-check
I64 position = start_of_waveform_data_packet_record + 60;
stream->seek(position);
char magic[25];
try { stream->getBytes((U8*)magic, 24); } catch(...)
{
fprintf(stderr,"ERROR: reading waveform descriptor cross-check\n");
return FALSE;
}
if (strncmp(magic, "LAStools waveform ", 18) == 0)
{
// do waveform descriptor cross-check
U16 i, number;
try { stream->get16bitsLE((U8*)&number); } catch(...)
{
fprintf(stderr,"ERROR: reading number of waveform descriptors\n");
return FALSE;
}
for (i = 0; i < number; i++)
{
U16 index;
try { stream->get16bitsLE((U8*)&index); } catch(...)
{
fprintf(stderr,"ERROR: reading index of waveform descriptor %d\n", i);
return FALSE;
}
if (index > 255)
{
fprintf(stderr,"ERROR: cross-check - index %d of waveform descriptor %d out-of-range\n", index, i);
return FALSE;
}
if (wave_packet_descr[index] == 0)
{
fprintf(stderr,"WARNING: cross-check - waveform descriptor %d with index %d unknown\n", i, index);
I32 dummy;
try { stream->get32bitsLE((U8*)&dummy); } catch(...)
{
fprintf(stderr,"ERROR: cross-check - reading rest of waveform descriptor %d\n", i);
return FALSE;
}
continue;
}
U8 compression;
try { stream->getBytes(&compression, 1); } catch(...)
{
fprintf(stderr,"ERROR: reading compression of waveform descriptor %d\n", i);
return FALSE;
}
if (compression != wave_packet_descr[index]->getCompressionType())
{
fprintf(stderr,"ERROR: cross-check - compression %d %d of waveform descriptor %d with index %d is different\n", compression, wave_packet_descr[index]->getCompressionType(), i, index);
return FALSE;
}
U8 nbits;
try { stream->getBytes(&nbits, 1); } catch(...)
{
fprintf(stderr,"ERROR: reading nbits of waveform descriptor %d\n", i);
return FALSE;
}
if (nbits != wave_packet_descr[index]->getBitsPerSample())
{
fprintf(stderr,"ERROR: cross-check - nbits %d %d of waveform descriptor %d with index %d is different\n", nbits, wave_packet_descr[index]->getBitsPerSample(), i, index);
return FALSE;
}
U16 nsamples;
try { stream->get16bitsLE((U8*)&nsamples); } catch(...)
{
fprintf(stderr,"ERROR: reading nsamples of waveform descriptor %d\n", i);
return FALSE;
}
if (nsamples != wave_packet_descr[index]->getNumberOfSamples())
{
fprintf(stderr,"ERROR: cross-check - nsamples %d %d of waveform descriptor %d with index %d is different\n", nsamples, wave_packet_descr[index]->getNumberOfSamples(), i, index);
return FALSE;
}
}
}
last_position = stream->tell();
// create decompressor
if (compressed)
{
if (dec == 0) dec = new ArithmeticDecoder();
if (ic8 == 0) ic8 = new IntegerCompressor(dec, 8);
if (ic16 == 0) ic16 = new IntegerCompressor(dec, 16);
}
return TRUE;
}
BOOL LASreadPoint::setup(U32 num_items, const LASitem* items, const LASzip* laszip)
{
U32 i;
// is laszip exists then we must use its items
if (laszip)
{
if (num_items != laszip->num_items) return FALSE;
if (items != laszip->items) return FALSE;
}
// create entropy decoder (if requested)
if (dec)
{
delete dec;
dec = 0;
}
if (laszip && laszip->compressor)
{
switch (laszip->coder)
{
case LASZIP_CODER_ARITHMETIC:
dec = new ArithmeticDecoder();
break;
default:
// entropy decoder not supported
return FALSE;
}
}
// initizalize the readers
readers = 0;
num_readers = num_items;
// disable chunking
chunk_size = U32_MAX;
// always create the raw readers
readers_raw = new LASreadItem*[num_readers];
for (i = 0; i < num_readers; i++)
{
switch (items[i].type)
{
case LASitem::POINT10:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_POINT10_LE();
else
readers_raw[i] = new LASreadItemRaw_POINT10_BE();
break;
case LASitem::GPSTIME11:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_GPSTIME11_LE();
else
readers_raw[i] = new LASreadItemRaw_GPSTIME11_BE();
break;
case LASitem::RGB12:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_RGB12_LE();
else
readers_raw[i] = new LASreadItemRaw_RGB12_BE();
break;
case LASitem::WAVEPACKET13:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_WAVEPACKET13_LE();
else
readers_raw[i] = new LASreadItemRaw_WAVEPACKET13_BE();
break;
case LASitem::BYTE:
readers_raw[i] = new LASreadItemRaw_BYTE(items[i].size);
break;
case LASitem::POINT14:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_POINT14_LE();
else
return FALSE;
break;
case LASitem::RGBNIR14:
if (IS_LITTLE_ENDIAN())
readers_raw[i] = new LASreadItemRaw_RGBNIR14_LE();
else
readers_raw[i] = new LASreadItemRaw_RGBNIR14_BE();
break;
default:
return FALSE;
}
point_size += items[i].size;
m_vtxSizeArray[i] = items[i].size;
}
m_vtxSize = point_size;
m_bufferSize = m_vtxSize * ReadVtxNum;
m_buffer = new U8[m_bufferSize];
if (dec)
{
readers_compressed = new LASreadItem*[num_readers];
// seeks with compressed data need a seek point
if (seek_point)
{
delete [] seek_point[0];
delete [] seek_point;
}
seek_point = new U8*[num_items];
if (!seek_point) return FALSE;
seek_point[0] = new U8[point_size];
if (!seek_point[0]) return FALSE;
for (i = 0; i < num_readers; i++)
{
switch (items[i].type)
{
case LASitem::POINT10:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_POINT10_v1(dec);
else if (items[i].version == 2)
readers_compressed[i] = new LASreadItemCompressed_POINT10_v2(dec);
else
return FALSE;
break;
case LASitem::GPSTIME11:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_GPSTIME11_v1(dec);
else if (items[i].version == 2)
readers_compressed[i] = new LASreadItemCompressed_GPSTIME11_v2(dec);
else
return FALSE;
break;
case LASitem::RGB12:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_RGB12_v1(dec);
else if (items[i].version == 2)
readers_compressed[i] = new LASreadItemCompressed_RGB12_v2(dec);
else
return FALSE;
break;
case LASitem::WAVEPACKET13:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_WAVEPACKET13_v1(dec);
else
return FALSE;
break;
case LASitem::BYTE:
if (items[i].version == 1)
readers_compressed[i] = new LASreadItemCompressed_BYTE_v1(dec, items[i].size);
else if (items[i].version == 2)
readers_compressed[i] = new LASreadItemCompressed_BYTE_v2(dec, items[i].size);
else
return FALSE;
break;
default:
return FALSE;
}
if (i) seek_point[i] = seek_point[i-1]+items[i-1].size;
}
if (laszip->compressor == LASZIP_COMPRESSOR_POINTWISE_CHUNKED)
{
if (laszip->chunk_size) chunk_size = laszip->chunk_size;
number_chunks = U32_MAX;
}
}
return TRUE;
}
