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