void DjVuSource::ReadAnnotations(GP<ByteStream> pInclStream, set<GUTF8String>& processed, GP<ByteStream> pAnnoStream) { // Look for shared annotations GUTF8String strInclude; char buf[1024]; int nLength; while ((nLength = pInclStream->read(buf, 1024))) strInclude += GUTF8String(buf, nLength); // Eat '\n' in the beginning and at the end while (strInclude.length() > 0 && strInclude[0] == '\n') strInclude = strInclude.substr(1, static_cast<unsigned int>(-1)); while (strInclude.length() > 0 && strInclude[static_cast<int>(strInclude.length()) - 1] == '\n') strInclude.setat(strInclude.length() - 1, 0); if (strInclude.length() > 0 && processed.find(strInclude) == processed.end()) { processed.insert(strInclude); GURL urlInclude = m_pDjVuDoc->id_to_url(strInclude); GP<DataPool> pool = m_pDjVuDoc->request_data(NULL, urlInclude); GP<ByteStream> stream = pool->get_stream(); GP<IFFByteStream> iff(IFFByteStream::create(stream)); // Check file format GUTF8String chkid; if (!iff->get_chunk(chkid) || (chkid != "FORM:DJVI" && chkid != "FORM:DJVU" && chkid != "FORM:PM44" && chkid != "FORM:BM44")) { return; } // Find chunk with page info while (iff->get_chunk(chkid) != 0) { GP<ByteStream> chunk_stream = iff->get_bytestream(); if (chkid == "INCL") { ReadAnnotations(pInclStream, processed, pAnnoStream); } else if (chkid == "FORM:ANNO") { pAnnoStream->copy(*chunk_stream); } else if (chkid == "ANTa" || chkid == "ANTz") { const GP<IFFByteStream> iffout = IFFByteStream::create(pAnnoStream); iffout->put_chunk(chkid); iffout->copy(*chunk_stream); iffout->close_chunk(); } iff->seek_close_chunk(); } } }
static void debug_parse(char *string, const char *error) { if (*string && strchr("~@&", *string)) { char *text = string + 1; const char *end; if (*text == '"') { end = parse_string(text, '\n'); dc_output(1, text, -1); } else { dc_output(1, string, -1); end = NULL; } if (error) dc_error("%s, ignoring to EOLN", error); else if (!end) dc_error("\" expected"); else if (g_str_has_prefix(string, "~^(Scope)#07")) on_inspect_signal(string + 12); } else if (!strcmp(string, "(gdb) ")) /* gdb.info says "(gdb)" */ { dc_output(3, "(gdb) ", 6); wait_prompt = wait_result; } else { char *message; for (message = string; isdigit(*message); message++); if (error || option_library_messages || !g_str_has_prefix(message, "=library-")) dc_output_nl(1, string, -1); if (*message == '^') { iff (wait_result, "extra result") wait_result--; } if (*string == '0' && message > string + 1) { memmove(string, string + 1, message - string - 1); message[-1] = '\0'; } else string = NULL; /* no token */ if (error) dc_error("%s, ignoring to EOLN", error); else parse_message(message, string); } }
void INIConfig::init(const string filename) { ifstream iff(filename.c_str()); string s, last_s, tag; char buf[1024]; while (iff >> s){ if ('#' == s[0]){ iff.getline(buf, 1023); continue; } if (s[0] == '[' && s[s.length() -1 ] == ']'){ tag = s; } else if (s == "=") {iff >> s; _config[tag][last_s] = s; } else
void on_debug_list_source(GArray *nodes) { ParseLocation loc; parse_location(nodes, &loc); iff (loc.line, "no line or abs file") debug_send_format(N, "02-break-insert -t %s:%d\n05", loc.file, loc.line); parse_location_free(&loc); }
void readsFeature(char* filename,double* e,int* p,int* index,double* threshold) { int t_p,t_index; double t_threshold,t_e; ifstream iff(filename); for(int i = 0;i < 200;i++) { iff>>t_e>>t_threshold>>t_p>>t_index; *(e+i) = t_e; *(threshold+i) = t_threshold; *(p+i) = t_p; *(index+i) = t_index; } }
/** * Return true if the object looks to be in good shape. Centralizes a number * of consistency checks that would otherwise clutter up the code, and, since * only ever called from within assertions, can be eliminated entirely by the * compiler from the release build. */ bool LimitedArena::consistent() const { assert(_parent != 0); // Validate the parent assert(_limit <= unlimited); // Now check that our assert(_available <= _limit); // various counters assert(_allocated <= _peakusage); // are within their assert(_peakusage <= _limit); // legal ranges... assert(_allocations <= unlimited); // assert(iff(_allocated==0,_allocations==0)); // Live=0 <=> Total=0 if (_available < unlimited) // Enforcing a limit? { assert(_allocated + _available == _limit); // ...check accounts } return true; // Seems to be kosher }
DataTable* DataTableManager::open(const std::string& table) { FATAL(!m_installed, ("DataTableManager::open: not installed.")); DataTable *retVal = getTable(table, false); if (retVal) return retVal; if (!TreeFile::exists(table.c_str())) { DEBUG_WARNING(true, ("Could not find treefile table for open [%s]", table.c_str())); return 0; } Iff iff(table.c_str(), false); retVal = new DataTable; retVal->load(iff); m_cachedTable = retVal; m_cachedTableName = table; m_tables[table] = retVal; return retVal; }
void readFeature(char* filename,int* feature,int featureNum) { ifstream iff(filename,ios::binary); if(!iff) { cout<<"error"<<endl; return; } int buff; int num = 0; while(iff.read((char*)&buff,sizeof(int))) { *(feature+num*featureNum) = buff; for(int i = 1;i < featureNum;i++) { iff.read((char*)&buff,sizeof(int)); *(feature+num*featureNum+i) = buff; } num++; } }
bool run(struct context *context, struct byte_array *program, struct map *env, bool in_context) { null_check(context); null_check(program); program = byte_array_copy(program); program->current = program->data; struct program_state *state = NULL; enum Opcode inst = VM_NIL; if (context->runtime) { if (in_context) { if (!state) state = (struct program_state*)stack_peek(context->program_stack, 0); env = state->named_variables; // use the caller's variable set in the new state } else state = program_state_new(context, env); } while (program->current < program->data + program->length) { inst = (enum Opcode)*program->current; bool really = inst & VM_RLY; inst &= ~VM_RLY; #ifdef DEBUG display_program_counter(context, program); #endif program->current++; // increment past the instruction int32_t pc_offset = 0; switch (inst) { case VM_COM: case VM_ITR: if (iterate(context, inst, state, program)) goto done; break; case VM_RET: if (ret(context, program)) goto done; break; case VM_TRO: if (tro(context)) goto done; break; case VM_TRY: if (vm_trycatch(context, program)) goto done; break; case VM_EQU: case VM_MUL: case VM_DIV: case VM_ADD: case VM_SUB: case VM_NEQ: case VM_GTN: case VM_LTN: case VM_GRQ: case VM_LEQ: case VM_BND: case VM_BOR: case VM_MOD: case VM_XOR: case VM_INV: case VM_RSF: case VM_LSF: binary_op(context, inst); break; case VM_ORR: case VM_AND: pc_offset = boolean_op(context, program, inst); break; case VM_NEG: case VM_NOT: unary_op(context, inst); break; case VM_SRC: src(context, inst, program); break; case VM_DST: dst(context, really); break; case VM_STX: case VM_SET: set(context, inst, state, program); break; case VM_JMP: pc_offset = jump(context, program); break; case VM_IFF: pc_offset = iff(context, program); break; case VM_CAL: func_call(context, inst, program, NULL); break; case VM_LST: push_list(context, program); break; case VM_MAP: push_map(context, program); break; case VM_NIL: push_nil(context); break; case VM_INT: push_int(context, program); break; case VM_FLT: push_float(context, program); break; case VM_BUL: push_bool(context, program); break; case VM_STR: push_str(context, program); break; case VM_VAR: push_var(context, program); break; case VM_FNC: push_fnc(context, program); break; case VM_GET: list_get(context, really); break; case VM_PTX: case VM_PUT: list_put(context, inst, really); break; case VM_MET: method(context, program, really); break; default: vm_exit_message(context, ERROR_OPCODE); return false; } program->current += pc_offset; } if (!context->runtime) return false; done: if (!in_context) stack_pop(context->program_stack); return inst == VM_RET; }
int main() { machines_state_t *root; machines_state_t *level_1; machines_state_t *level_2; machines_state_t *menu; machines_state_t *level_1_play; machines_state_t *level_1_quit; machines_state_t *level_2_play; machines_state_t *level_2_quit; machines_dot_t *dot = machines_new_dot("test_gameplay", stdlib_memory); char *dot_out = (char*)malloc(16384); int condition_level_1 = 0; int condition_level_2 = 0; int condition_quit = 0; root = machines_new_state("root", NULL, stdlib_memory); level_1 = machines_new_state("level 1", root, stdlib_memory); level_2 = machines_new_state("level 2", root, stdlib_memory); menu = machines_new_state("menu", root, stdlib_memory); level_1_play = machines_new_state("play level 1", level_1, stdlib_memory); level_1_quit = machines_new_state("quit level 1", level_1, stdlib_memory); level_2_play = machines_new_state("play level 2", level_2, stdlib_memory); level_2_quit = machines_new_state("quit level 2", level_2, stdlib_memory); root ->add_entry(root , dot->on_entry(dot, "root ")); level_1 ->add_entry(level_1 , dot->on_entry(dot, "level_1 ")); level_2 ->add_entry(level_2 , dot->on_entry(dot, "level_2 ")); menu ->add_entry(menu , dot->on_entry(dot, "menu ")); level_1_play->add_entry(level_1_play, dot->on_entry(dot, "level_1_play")); level_1_quit->add_entry(level_1_quit, dot->on_entry(dot, "level_1_quit")); level_2_play->add_entry(level_2_play, dot->on_entry(dot, "level_2_play")); level_2_quit->add_entry(level_2_quit, dot->on_entry(dot, "level_2_quit")); root ->add_exit(root , dot->on_exit(dot, "root ")); level_1 ->add_exit(level_1 , dot->on_exit(dot, "level_1 ")); level_2 ->add_exit(level_2 , dot->on_exit(dot, "level_2 ")); menu ->add_exit(menu , dot->on_exit(dot, "menu ")); level_1_play->add_exit(level_1_play, dot->on_exit(dot, "level_1_play")); level_1_quit->add_exit(level_1_quit, dot->on_exit(dot, "level_1_quit")); level_2_play->add_exit(level_2_play, dot->on_exit(dot, "level_2_play")); level_2_quit->add_exit(level_2_quit, dot->on_exit(dot, "level_2_quit")); root->entry_at(root, menu); menu->add_transition(menu, level_1, dot->transition(dot, "menu->level_1", iff("menu->level_1", &condition_level_1))); menu->add_transition(menu, level_2, dot->transition(dot, "menu->level_2", iff("menu->level_2", &condition_level_2))); level_1->add_transition(level_1, menu, dot->transition(dot, "level_1->menu", always_true("level 1 finished, back to menu"))); level_2->add_transition(level_2, menu, dot->transition(dot, "level_1->menu", always_true("level 2 finished, back to menu"))); level_1->entry_at(level_1, level_1_play); level_1->exit_at(level_1, level_1_quit); level_1_play->add_transition(level_1_play, level_1_quit, dot->transition(dot, "level_1_play->level_1_quit", iff("play->quit", &condition_quit))); level_1_play->add_transition(level_1_play, level_1_play, dot->transition(dot, "level_1_play->level_1_play", always_true("continue playing level 1"))); // note that transitions are checked in order until first match level_2->entry_at(level_2, level_2_play); level_2->exit_at(level_2, level_2_quit); level_2_play->add_transition(level_2_play, level_2_quit, dot->transition(dot, "level_2_play->level_2_quit", iff("play->quit", &condition_quit))); level_2_play->add_transition(level_2_play, level_2_play, dot->transition(dot, "level_2_play->level_2_play", always_true("continue playing level 2"))); // note that transitions are checked in order until first match // application startup printf("**** trigger: go to menu\n"); root->trigger(root); assert(root->current(root) == menu); // the menu is displayed; the user chooses the first level condition_level_1 = 1; printf("**** trigger: go to first level\n"); root->trigger(root); assert(root->current(root) == level_1); assert(level_1->current(level_1) == level_1_play); // the user keeps playing printf("**** trigger: keep playing\n"); root->trigger(root); assert(root->current(root) == level_1); assert(level_1->current(level_1) == level_1_play); // the user reaches the end of the level condition_quit = 1; printf("**** trigger: exit level\n"); root->trigger(root); assert(root->current(root) == level_1); assert(level_1->current(level_1) == level_1_quit); // the user returns to the menu printf("**** trigger: back to the menu\n"); root->trigger(root); assert(root->current(root) == menu); // (a bit of internal cleanup) condition_level_1 = 0; condition_quit = 0; // the menu is displayed; the user chooses the second level condition_level_2 = 1; printf("**** trigger: go to second level\n"); root->trigger(root); assert(root->current(root) == level_2); assert(level_2->current(level_2) == level_2_play); // the user keeps playing printf("**** trigger: keep playing\n"); root->trigger(root); assert(root->current(root) == level_2); assert(level_2->current(level_2) == level_2_play); // the user keeps playing printf("**** trigger: keep playing\n"); root->trigger(root); assert(root->current(root) == level_2); assert(level_2->current(level_2) == level_2_play); // the user keeps playing printf("**** trigger: keep playing\n"); root->trigger(root); assert(root->current(root) == level_2); assert(level_2->current(level_2) == level_2_play); // the user reaches the end of the level condition_quit = 1; printf("**** trigger: exit level\n"); root->trigger(root); assert(root->current(root) == level_2); assert(level_2->current(level_2) == level_2_quit); // the user returns to the menu printf("**** trigger: back to the menu\n"); root->trigger(root); assert(root->current(root) == menu); dot->generate(dot, dot_out, 16384); printf("--8<--------------------------------------------------------------------\n"); printf(dot_out); printf("-------------------------------------------------------------------->8--\n"); return 0; }
void figureFeature(char* img,double scale,int length,int width) { int windowLen = scale*(double)len; int windowWid = scale*(double)wid; int windowMove = scale*4.0; unsigned char* smallImg = new unsigned char[windowLen*windowWid]; int* accimg = new int[windowWid*windowLen]; int ff_x1[200],ff_y1[200],ff_x2[200],ff_y2[200],f_kind[200]; ifstream iff("finalFeature.txt"); for(int i = 0;i < 200;i++) { iff>>ff_x1[i]>>ff_y1[i]>>ff_x2[i]>>ff_y2[i]>>f_kind[i]; ff_x1[i] = ff_x1[i]*scale; ff_y1[i] = ff_y1[i]*scale; ff_x2[i] = ff_x2[i]*scale; ff_y2[i] = ff_y2[i]*scale; } iff.close(); int* f_p = new int[200]; double* f_e = new double[200]; double* f_threshold = new double[200]; int* f_featureIndex = new int[200]; readsFeature("feature.txt",f_e,f_p,f_featureIndex,f_threshold); int face = 0; for(int i = 0;i < length;i+=windowMove) for(int j = 0;j < width;j+=windowMove) { if(i+windowLen>length || j+windowWid>width) continue; for(int m = 0;m < windowLen;m++) for(int n = 0;n < windowWid;n++) { char tmp = *(img+(i+m)*width+n+j); *(smallImg+m*windowWid+n) = (unsigned char)tmp; } Mat graph(Size(windowWid,windowLen), CV_8U, smallImg); cv::namedWindow("foobar1"); cv::imshow("foobar1", graph); cv::waitKey(0); accumulativeGraph((unsigned char*)smallImg,accimg,windowLen,windowWid); /* for(int i = 0;i< 10;i++) { for(int j = 0;j < 10;j++) cout << (int)*(smallImg+i*windowWid+j)<<" "; cout<<endl; } for(int i = 0;i< 10;i++) { for(int j = 0;j < 10;j++) cout << (int)*(accimg+i*windowWid+j)<<" "; cout<<endl; }*/ int tfeature = 0; double sum1 = 0,sum2 = 0; for(int i = 0;i < 200;i++) { if(f_kind[i] == 1) tfeature = calRectFeature1(accimg,ff_x1[i],ff_y1[i],ff_x2[i],ff_y2[i],windowWid,windowLen); else if(f_kind[i] == 2) tfeature = calRectFeature2(accimg,ff_x1[i],ff_y1[i],ff_x2[i],ff_y2[i],windowWid,windowLen); else if(f_kind[i] == 3) tfeature = calRectFeature3(accimg,ff_x1[i],ff_y1[i],ff_x2[i],ff_y2[i],windowWid,windowLen); else if(f_kind[i] == 4) tfeature = calRectFeature4(accimg,ff_x1[i],ff_y1[i],ff_x2[i],ff_y2[i],windowWid,windowLen); tfeature = tfeature/scale; double beta = *(f_e+i)/(1.0-*(f_e+i)); double at = log(1.0/beta); if((*(f_p+i)*tfeature)<*(f_p+i)*(*(f_threshold+i))) sum1 += at; sum2 += at; } if(sum1 > sum2/2) { cout<<"face"<<endl; face++; } else cout<<"not face"<<endl; } }
int main(int argc, char* argv[]){ std::string pose_offset_filename = "./poseoffset"; unsigned cv_width = 128; unsigned cv_height = 128; unsigned cv_depth = 128; float cv_min_d = 0.5; float cv_max_d = 3.0; bool undistort = false; unsigned idwneighbours = 10; bool using_nni = false; CMDParser p("basefilename samplesfilename checkerboardviewinitfilename"); p.addOpt("p",1,"poseoffetfilename", "specify the filename of the poseoffset on disk, default: " + pose_offset_filename); p.addOpt("s",3,"size", "use this calibration volume size (width x height x depth), default: 128 128 256"); p.addOpt("d",2,"depthrange", "use this depth range: 0.5 4.5"); p.addOpt("u", -1, "undistort", "enable undistortion of images before chessboardsampling, default: false"); p.addOpt("n",1,"numneighbours", "the number of neighbours that should be used for IDW inverse distance weighting, default: 10"); p.addOpt("i",-1,"nni", "do use natural neighbor interpolation if possible, default: false"); p.init(argc,argv); if(p.getArgs().size() != 3) p.showHelp(); if(p.isOptSet("p")){ pose_offset_filename = p.getOptsString("p")[0]; std::cout << "setting poseoffetfilename to " << pose_offset_filename << std::endl; } if(p.isOptSet("s")){ cv_width = p.getOptsInt("s")[0]; cv_height = p.getOptsInt("s")[1]; cv_depth = p.getOptsInt("s")[2]; } if(p.isOptSet("d")){ cv_min_d = p.getOptsInt("d")[0]; cv_max_d = p.getOptsInt("d")[1]; } if(p.isOptSet("u")){ undistort = true; } if(p.isOptSet("n")){ idwneighbours = p.getOptsInt("n")[0]; std::cout << "setting to numneighbours " << idwneighbours << std::endl; } if(p.isOptSet("i")){ using_nni = true; } std::string basefilename = p.getArgs()[0]; std::string filename_xyz(basefilename + "_xyz"); std::string filename_uv(basefilename + "_uv"); const std::string filename_yml(basefilename + "_yml"); std::string filename_samples(p.getArgs()[1]); CalibVolume cv(cv_width, cv_height, cv_depth, cv_min_d, cv_max_d); RGBDConfig cfg; cfg.read(filename_yml.c_str()); RGBDSensor sensor(cfg); Checkerboard cb; cb.load_pose_offset(pose_offset_filename.c_str()); ChessboardSampling cbs(p.getArgs()[2].c_str(), cfg, undistort); cbs.init(); glm::mat4 eye_d_to_world = sensor.guess_eye_d_to_world_static(cbs, cb); std::cerr << "extrinsic of sensor is: " << eye_d_to_world << std::endl; std::cerr << "PLEASE note, the extrinsic guess can be improved by averaging" << std::endl; for(unsigned z = 0; z < cv.depth; ++z){ for(unsigned y = 0; y < cv.height; ++y){ for(unsigned x = 0; x < cv.width; ++x){ const unsigned cv_index = (z * cv.width * cv.height) + (y * cv.width) + x; const float depth = (z + 0.5) * (cv.max_d - cv.min_d)/cv.depth + cv.min_d; const float xd = (x + 0.5) * sensor.config.size_d.x * 1.0/cv.width; const float yd = (y + 0.5) * sensor.config.size_d.y * 1.0/cv.height; glm::vec3 pos3D_local = sensor.calc_pos_d(xd, yd, depth); glm::vec2 pos2D_rgb = sensor.calc_pos_rgb(pos3D_local); pos2D_rgb.x /= sensor.config.size_rgb.x; pos2D_rgb.y /= sensor.config.size_rgb.y; glm::vec4 pos3D_world = eye_d_to_world * glm::vec4(pos3D_local.x, pos3D_local.y, pos3D_local.z, 1.0); xyz pos3D; pos3D.x = pos3D_world.x; pos3D.y = pos3D_world.y; pos3D.z = pos3D_world.z; cv.cv_xyz[cv_index] = pos3D; uv posUV; posUV.u = pos2D_rgb.x; posUV.v = pos2D_rgb.y; cv.cv_uv[cv_index] = posUV; } } } // load samples from filename std::vector<samplePoint> sps; std::ifstream iff(filename_samples.c_str(), std::ifstream::binary); const unsigned num_samples_in_file = calcNumFrames(iff, sizeof(float) + sizeof(uv) + sizeof(uv) + sizeof(xyz) + sizeof(uv) + sizeof(glm::vec3) + sizeof(float)); for(unsigned i = 0; i < num_samples_in_file; ++i){ samplePoint s; iff.read((char*) &s.depth, sizeof(float)); iff.read((char*) &s.tex_color, sizeof(uv)); iff.read((char*) &s.tex_depth, sizeof(uv)); iff.read((char*) &s.pos_offset, sizeof(xyz)); iff.read((char*) &s.tex_offset, sizeof(uv)); iff.read((char*) glm::value_ptr(s.pos_real), sizeof(glm::vec3)); iff.read((char*) &s.quality, sizeof(float)); sps.push_back(s); } iff.close(); // reapply correction offsets for(unsigned i = 0; i < sps.size(); ++i){ const unsigned cv_width = cv.width; const unsigned cv_height = cv.height; const unsigned cv_depth = cv.depth; const float x = cv_width * ( sps[i].tex_depth.u) / cfg.size_d.x; const float y = cv_height * ( sps[i].tex_depth.v)/ cfg.size_d.y; const float z = cv_depth * ( sps[i].depth - cv.min_d)/(cv.max_d - cv.min_d); xyz pos = getTrilinear(cv.cv_xyz, cv_width, cv_height, cv_depth, x , y , z ); uv tex = getTrilinear(cv.cv_uv, cv_width, cv_height, cv_depth, x , y , z ); sps[i].pos_offset.x = sps[i].pos_real[0] - pos.x; sps[i].pos_offset.y = sps[i].pos_real[1] - pos.y; sps[i].pos_offset.z = sps[i].pos_real[2] - pos.z; sps[i].tex_offset.u = sps[i].tex_color.u/cfg.size_rgb.x - tex.u; sps[i].tex_offset.v = sps[i].tex_color.v/cfg.size_rgb.y - tex.v; sps[i].quality = 1.0f; } Calibrator c; c.using_nni = using_nni; c.applySamples(&cv, sps, cfg, idwneighbours, basefilename.c_str()); cv.save(filename_xyz.c_str(), filename_uv.c_str()); return 0; }
PageInfo DjVuSource::ReadPageInfo(int nPage, bool bNeedText, bool bNeedAnno) { ASSERT(nPage >= 0 && nPage < m_nPageCount); PageInfo pageInfo; pageInfo.szPage.cx = 100; pageInfo.szPage.cy = 100; pageInfo.nDPI = 100; pageInfo.bDecoded = true; GP<ByteStream> pAnnoStream; if (bNeedAnno) pAnnoStream = ByteStream::create(); GP<ByteStream> pTextStream; if (bNeedText) pTextStream = ByteStream::create(); try { // Get raw data from the document and decode only requested chunks // DjVuFile is not used to ensure that we do not wait for a lock // to be released and thus do not block the UI thread GURL url = m_pDjVuDoc->page_to_url(nPage); GP<DataPool> pool = m_pDjVuDoc->request_data(NULL, url); GP<ByteStream> stream = pool->get_stream(); GP<IFFByteStream> iff(IFFByteStream::create(stream)); // Check file format GUTF8String chkid; if (!iff->get_chunk(chkid) || (chkid != "FORM:DJVI" && chkid != "FORM:DJVU" && chkid != "FORM:PM44" && chkid != "FORM:BM44")) { return pageInfo; } bool bHasIW44 = false; // Find chunk with page info while (iff->get_chunk(chkid) != 0) { GP<ByteStream> chunk_stream = iff->get_bytestream(); if (chkid == "INFO") { // Get page dimensions and resolution from info chunk GP<DjVuInfo> pInfo = DjVuInfo::create(); pInfo->decode(*chunk_stream); // Check data for consistency pageInfo.szPage.cx = max(pInfo->width, 0); pageInfo.szPage.cy = max(pInfo->height, 0); pageInfo.nInitialRotate = pInfo->orientation; pageInfo.nDPI = max(pInfo->dpi, 0); if ((pInfo->orientation & 1) != 0) swap(pageInfo.szPage.cx, pageInfo.szPage.cy); } else if (!bHasIW44 && (chkid == "PM44" || chkid == "BM44")) { bHasIW44 = true; // Get image dimensions and resolution from bitmap chunk UINT serial = chunk_stream->read8(); UINT slices = chunk_stream->read8(); UINT major = chunk_stream->read8(); UINT minor = chunk_stream->read8(); UINT xhi = chunk_stream->read8(); UINT xlo = chunk_stream->read8(); UINT yhi = chunk_stream->read8(); UINT ylo = chunk_stream->read8(); pageInfo.szPage.cx = (xhi << 8) | xlo; pageInfo.szPage.cy = (yhi << 8) | ylo; pageInfo.nDPI = 100; } else if (chkid == "TXTa" || chkid == "TXTz") { pageInfo.bHasText = true; if (bNeedText) { const GP<IFFByteStream> iffout = IFFByteStream::create(pTextStream); iffout->put_chunk(chkid); iffout->copy(*chunk_stream); iffout->close_chunk(); } } else if (bNeedAnno && chkid == "FORM:ANNO") { pAnnoStream->copy(*chunk_stream); } else if (bNeedAnno && (chkid == "ANTa" || chkid == "ANTz")) { const GP<IFFByteStream> iffout = IFFByteStream::create(pAnnoStream); iffout->put_chunk(chkid); iffout->copy(*chunk_stream); iffout->close_chunk(); } else if (bNeedAnno && chkid == "INCL") { set<GUTF8String> processed; ReadAnnotations(chunk_stream, processed, pAnnoStream); } iff->seek_close_chunk(); } if (bNeedText && pTextStream->tell()) pageInfo.DecodeText(pTextStream); if (bNeedAnno && pAnnoStream->tell()) pageInfo.DecodeAnno(pAnnoStream); } catch (GException&) { } catch (...) { if (pApplication != NULL) pApplication->ReportFatalError(); } return pageInfo; }