void select_glDrawElements(const pointer_state_t* vtx, GLenum mode, GLuint count, GLenum type, GLvoid * indices) { if (count == 0) return; if (vtx->pointer == NULL) return; GLushort *sind = (GLushort*)((type==GL_UNSIGNED_SHORT)?indices:NULL); GLuint *iind = (GLuint*)((type==GL_UNSIGNED_INT)?indices:NULL); GLsizei min, max; if(sind) getminmax_indices_us(sind, &max, &min, count); else getminmax_indices_ui(iind, &max, &min, count); max++; GLfloat *vert = copy_gl_array(vtx->pointer, vtx->type, vtx->size, vtx->stride, GL_FLOAT, 4, 0, max); GLfloat zmin=1e10f, zmax=-10e6f; int found = 0; for (int i=min; i<max; i++) { select_transform(vert+i*4); ZMinMax(&glstate->selectbuf.zminoverall, &glstate->selectbuf.zmaxoverall, vert+i*4); } #define FOUND() { \ found = 1; \ glstate->selectbuf.hit = 1; \ } if(sind) { for (int i=0; i<count; i++) { switch (mode) { case GL_POINTS: if (select_point_in_viewscreen(vert+sind[i]*4)) { ZMinMax(&zmin, &zmax, vert+sind[i]*4); FOUND(); } break; case GL_LINES: if (i%2==1) { if (select_segment_in_viewscreen(vert+sind[(i-1)]*4, vert+sind[i]*4)) { ZMinMax(&zmin, &zmax, vert+sind[i-1]*4); ZMinMax(&zmin, &zmax, vert+sind[i]*4); FOUND(); } } break; case GL_LINE_STRIP: case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here if (i>0) { if (select_segment_in_viewscreen(vert+sind[(i-1)]*4, vert+sind[i]*4)) { ZMinMax(&zmin, &zmax, vert+sind[i-1]*4); ZMinMax(&zmin, &zmax, vert+sind[i]*4); FOUND(); } } break; case GL_TRIANGLES: if (i%3==2) { if (select_triangle_in_viewscreen(vert+sind[(i-2)]*4, vert+sind[(i-1)]*4, vert+sind[i]*4)) { ZMinMax(&zmin, &zmax, vert+sind[i-2]*4); ZMinMax(&zmin, &zmax, vert+sind[i-1]*4); ZMinMax(&zmin, &zmax, vert+sind[i]*4); FOUND(); } } break; case GL_TRIANGLE_STRIP: if (i>1) { if (select_triangle_in_viewscreen(vert+sind[(i-2)]*4, vert+sind[(i-1)]*4, vert+sind[i]*4)) { ZMinMax(&zmin, &zmax, vert+sind[i-2]*4); ZMinMax(&zmin, &zmax, vert+sind[i-1]*4); ZMinMax(&zmin, &zmax, vert+sind[i]*4); FOUND(); } } break; case GL_TRIANGLE_FAN: if (i>1) { if (select_triangle_in_viewscreen(vert+sind[0]*4, vert+sind[(i-1)]*4, vert+sind[i]*4)) ZMinMax(&zmin, &zmax, vert+sind[0]*4); ZMinMax(&zmin, &zmax, vert+sind[i-1]*4); ZMinMax(&zmin, &zmax, vert+sind[i]*4); FOUND(); } break; default: return; // Should never go there! } } } else { for (int i=0; i<count; i++) { switch (mode) { case GL_POINTS: if (select_point_in_viewscreen(vert+iind[i]*4)) { ZMinMax(&zmin, &zmax, vert+iind[i]*4); FOUND(); } break; case GL_LINES: if (i%2==1) { if (select_segment_in_viewscreen(vert+iind[(i-1)]*4, vert+iind[i]*4)) { ZMinMax(&zmin, &zmax, vert+iind[i-1]*4); ZMinMax(&zmin, &zmax, vert+iind[i]*4); FOUND(); } } break; case GL_LINE_STRIP: case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here if (i>0) { if (select_segment_in_viewscreen(vert+iind[(i-1)]*4, vert+iind[i]*4)) { ZMinMax(&zmin, &zmax, vert+iind[i-1]*4); ZMinMax(&zmin, &zmax, vert+iind[i]*4); FOUND(); } } break; case GL_TRIANGLES: if (i%3==2) { if (select_triangle_in_viewscreen(vert+iind[(i-2)]*4, vert+iind[(i-1)]*4, vert+iind[i]*4)) { ZMinMax(&zmin, &zmax, vert+iind[i-2]*4); ZMinMax(&zmin, &zmax, vert+iind[i-1]*4); ZMinMax(&zmin, &zmax, vert+iind[i]*4); FOUND(); } } break; case GL_TRIANGLE_STRIP: if (i>1) { if (select_triangle_in_viewscreen(vert+iind[(i-2)]*4, vert+iind[(i-1)]*4, vert+iind[i]*4)) { ZMinMax(&zmin, &zmax, vert+iind[i-2]*4); ZMinMax(&zmin, &zmax, vert+iind[i-1]*4); ZMinMax(&zmin, &zmax, vert+iind[i]*4); FOUND(); } } break; case GL_TRIANGLE_FAN: if (i>1) { if (select_triangle_in_viewscreen(vert+iind[0]*4, vert+iind[(i-1)]*4, vert+iind[i]*4)) ZMinMax(&zmin, &zmax, vert+iind[0]*4); ZMinMax(&zmin, &zmax, vert+iind[i-1]*4); ZMinMax(&zmin, &zmax, vert+iind[i]*4); FOUND(); } break; default: return; // Should never go there! } } } free(vert); if(found) { if (zmin<glstate->selectbuf.zmin) glstate->selectbuf.zmin=zmin; if (zmax>glstate->selectbuf.zmax) glstate->selectbuf.zmax=zmax; } #undef FOUND }
parse_switches (j_compress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real) /* Parse optional switches. * Returns argv[] index of first file-name argument (== argc if none). * Any file names with indexes <= last_file_arg_seen are ignored; * they have presumably been processed in a previous iteration. * (Pass 0 for last_file_arg_seen on the first or only iteration.) * for_real is FALSE on the first (dummy) pass; we may skip any expensive * processing. */ { int argn; char * arg; boolean simple_progressive; char * scansarg = NULL; /* saves -scans parm if any */ /* Set up default JPEG parameters. */ simple_progressive = FALSE; outfilename = NULL; copyoption = JCOPYOPT_DEFAULT; transformoption.transform = JXFORM_NONE; transformoption.trim = FALSE; transformoption.force_grayscale = FALSE; cinfo->err->trace_level = 0; /* Scan command line options, adjust parameters */ for (argn = 1; argn < argc; argn++) { arg = argv[argn]; if (*arg != '-') { /* Not a switch, must be a file name argument */ if (argn <= last_file_arg_seen) { outfilename = NULL; /* -outfile applies to just one input file */ continue; /* ignore this name if previously processed */ } break; /* else done parsing switches */ } arg++; /* advance past switch marker character */ if (keymatch(arg, "arithmetic", 1)) { /* Use arithmetic coding. */ #ifdef C_ARITH_CODING_SUPPORTED cinfo->arith_code = TRUE; #else fprintf(stderr, "%s: sorry, arithmetic coding not supported\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "copy", 1)) { /* Select which extra markers to copy. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "none", 1)) { copyoption = JCOPYOPT_NONE; } else if (keymatch(argv[argn], "comments", 1)) { copyoption = JCOPYOPT_COMMENTS; } else if (keymatch(argv[argn], "all", 1)) { copyoption = JCOPYOPT_ALL; } else usage(); } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) { /* Enable debug printouts. */ /* On first -d, print version identification */ static boolean printed_version = FALSE; if (! printed_version) { fprintf(stderr, "Independent JPEG Group's JPEGTRAN, version %s\n%s\n", JVERSION, JCOPYRIGHT); printed_version = TRUE; } cinfo->err->trace_level++; } else if (keymatch(arg, "flip", 1)) { /* Mirror left-right or top-bottom. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "horizontal", 1)) select_transform(JXFORM_FLIP_H); else if (keymatch(argv[argn], "vertical", 1)) select_transform(JXFORM_FLIP_V); else usage(); } else if (keymatch(arg, "grayscale", 1) || keymatch(arg, "greyscale",1)) { /* Force to grayscale. */ #if TRANSFORMS_SUPPORTED transformoption.force_grayscale = TRUE; #else select_transform(JXFORM_NONE); /* force an error */ #endif } else if (keymatch(arg, "maxmemory", 3)) { /* Maximum memory in Kb (or Mb with 'm'). */ long lval; char ch = 'x'; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (ch == 'm' || ch == 'M') lval *= 1000L; cinfo->mem->max_memory_to_use = lval * 1000L; } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) { /* Enable entropy parm optimization. */ #ifdef ENTROPY_OPT_SUPPORTED cinfo->optimize_coding = TRUE; #else fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "outfile", 4)) { /* Set output file name. */ if (++argn >= argc) /* advance to next argument */ usage(); outfilename = argv[argn]; /* save it away for later use */ } else if (keymatch(arg, "progressive", 1)) { /* Select simple progressive mode. */ #ifdef C_PROGRESSIVE_SUPPORTED simple_progressive = TRUE; /* We must postpone execution until num_components is known. */ #else fprintf(stderr, "%s: sorry, progressive output was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "restart", 1)) { /* Restart interval in MCU rows (or in MCUs with 'b'). */ long lval; char ch = 'x'; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (lval < 0 || lval > 65535L) usage(); if (ch == 'b' || ch == 'B') { cinfo->restart_interval = (unsigned int) lval; cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */ } else { cinfo->restart_in_rows = (int) lval; /* restart_interval will be computed during startup */ } } else if (keymatch(arg, "rotate", 2)) { /* Rotate 90, 180, or 270 degrees (measured clockwise). */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "90", 2)) select_transform(JXFORM_ROT_90); else if (keymatch(argv[argn], "180", 3)) select_transform(JXFORM_ROT_180); else if (keymatch(argv[argn], "270", 3)) select_transform(JXFORM_ROT_270); else usage(); } else if (keymatch(arg, "scans", 1)) { /* Set scan script. */ #ifdef C_MULTISCAN_FILES_SUPPORTED if (++argn >= argc) /* advance to next argument */ usage(); scansarg = argv[argn]; /* We must postpone reading the file in case -progressive appears. */ #else fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "transpose", 1)) { /* Transpose (across UL-to-LR axis). */ select_transform(JXFORM_TRANSPOSE); } else if (keymatch(arg, "transverse", 6)) { /* Transverse transpose (across UR-to-LL axis). */ select_transform(JXFORM_TRANSVERSE); } else if (keymatch(arg, "trim", 3)) { /* Trim off any partial edge MCUs that the transform can't handle. */ transformoption.trim = TRUE; } else { usage(); /* bogus switch */ } } /* Post-switch-scanning cleanup */ if (for_real) { #ifdef C_PROGRESSIVE_SUPPORTED if (simple_progressive) /* process -progressive; -scans can override */ jpeg_simple_progression(cinfo); #endif #ifdef C_MULTISCAN_FILES_SUPPORTED if (scansarg != NULL) /* process -scans if it was present */ if (! read_scan_script(cinfo, scansarg)) usage(); #endif } return argn; /* return index of next arg (file name) */ }
void select_glDrawArrays(const pointer_state_t* vtx, GLenum mode, GLuint first, GLuint count) { if (count == 0) return; if (vtx->pointer == NULL) return; if (glstate->selectbuf.buffer == NULL) return; GLfloat *vert = copy_gl_array(vtx->pointer, vtx->type, vtx->size, vtx->stride, GL_FLOAT, 4, 0, count+first); GLfloat zmin=1e10f, zmax=-1e10f; int found = 0; #define FOUND() { \ found = 1; \ glstate->selectbuf.hit = 1; \ } // transform the points for (int i=first; i<count+first; i++) { select_transform(vert+i*4); ZMinMax(&glstate->selectbuf.zminoverall, &glstate->selectbuf.zmaxoverall, vert+i*4); } // intersect with screen now GLfloat *vert2 = vert + first*4; for (int i=0; i<count; i++) { switch (mode) { case GL_POINTS: if (select_point_in_viewscreen(vert2+i*4)) { ZMinMax(&zmin, &zmax, vert+i*4); FOUND(); } break; case GL_LINES: if (i%2==1) { if (select_segment_in_viewscreen(vert2+(i-1)*4, vert2+i*4)) { ZMinMax(&zmin, &zmax, vert+(i-1)*4); ZMinMax(&zmin, &zmax, vert+i*4); FOUND(); } } break; case GL_LINE_STRIP: case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here if (i>0) { if (select_segment_in_viewscreen(vert2+(i-1)*4, vert2+i*4)) { ZMinMax(&zmin, &zmax, vert+(i-1)*4); ZMinMax(&zmin, &zmax, vert+i*4); FOUND(); } } break; case GL_TRIANGLES: if (i%3==2) { if (select_triangle_in_viewscreen(vert2+(i-2)*4, vert2+(i-1)*4, vert2+i*4)) { ZMinMax(&zmin, &zmax, vert+(i-2)*4); ZMinMax(&zmin, &zmax, vert+(i-1)*4); ZMinMax(&zmin, &zmax, vert+i*4); FOUND(); } } break; case GL_TRIANGLE_STRIP: if (i>1) { if (select_triangle_in_viewscreen(vert2+(i-2)*4, vert2+(i-1)*4, vert2+i*4)) { ZMinMax(&zmin, &zmax, vert+(i-2)*4); ZMinMax(&zmin, &zmax, vert+(i-1)*4); ZMinMax(&zmin, &zmax, vert+i*4); FOUND(); } } break; case GL_TRIANGLE_FAN: if (i>1) { if (select_triangle_in_viewscreen(vert2, vert2+(i-1)*4, vert2+i*4)) { ZMinMax(&zmin, &zmax, vert); ZMinMax(&zmin, &zmax, vert+(i-1)*4); ZMinMax(&zmin, &zmax, vert+i*4); FOUND(); } } break; default: return; // Should never go there! } } free(vert); if(found) { if (zmin<glstate->selectbuf.zmin) glstate->selectbuf.zmin=zmin; if (zmax>glstate->selectbuf.zmax) glstate->selectbuf.zmax=zmax; } #undef FOUND }
static int add_sensor (int dev_num, int catalog_index, int mode) { int s; int sensor_type; int retval; char sysfs_path[PATH_MAX]; const char* prefix; float scale; int c; float opt_scale; const char* ch_name; int num_channels; char suffix[MAX_NAME_SIZE + 8]; int calib_bias; int buffer_length; if (sensor_count == MAX_SENSORS) { ALOGE("Too many sensors!\n"); return -1; } sensor_type = sensor_catalog[catalog_index].type; /* * At this point we could check that the expected sysfs attributes are * present ; that would enable having multiple catalog entries with the * same sensor type, accomodating different sets of sysfs attributes. */ s = sensor_count; sensor[s].dev_num = dev_num; sensor[s].catalog_index = catalog_index; sensor[s].type = sensor_type; sensor[s].mode = mode; sensor[s].trigger_nr = -1; /* -1 means no trigger - we'll populate these at a later time */ num_channels = sensor_catalog[catalog_index].num_channels; if (mode == MODE_POLL) sensor[s].num_channels = 0; else sensor[s].num_channels = num_channels; /* Populate the quirks array */ sensor_get_quirks(s); /* Reject interfaces that may have been disabled through a quirk for this driver */ if ((mode == MODE_EVENT && (sensor[s].quirks & QUIRK_NO_EVENT_MODE)) || (mode == MODE_TRIGGER && (sensor[s].quirks & QUIRK_NO_TRIG_MODE )) || (mode == MODE_POLL && (sensor[s].quirks & QUIRK_NO_POLL_MODE ))) { memset(&sensor[s], 0, sizeof(sensor[0])); return -1; } prefix = sensor_catalog[catalog_index].tag; /* * receiving the illumination sensor calibration inputs from * the Android properties and setting it within sysfs */ if (sensor_type == SENSOR_TYPE_INTERNAL_ILLUMINANCE) { retval = sensor_get_illumincalib(s); if (retval > 0) { sprintf(sysfs_path, ILLUMINATION_CALIBPATH, dev_num); sysfs_write_int(sysfs_path, retval); } } /* * See if we have optional calibration biases for each of the channels of this sensor. These would be expressed using properties like * iio.accel.y.calib_bias = -1, or possibly something like iio.temp.calib_bias if the sensor has a single channel. This value gets stored in the * relevant calibbias sysfs file if that file can be located and then used internally by the iio sensor driver. */ if (num_channels) { for (c = 0; c < num_channels; c++) { ch_name = sensor_catalog[catalog_index].channel[c].name; sprintf(suffix, "%s.calib_bias", ch_name); if (!sensor_get_prop(s, suffix, &calib_bias) && calib_bias) { sprintf(suffix, "%s_%s", prefix, sensor_catalog[catalog_index].channel[c].name); sprintf(sysfs_path, SENSOR_CALIB_BIAS_PATH, dev_num, suffix); sysfs_write_int(sysfs_path, calib_bias); } } } else if (!sensor_get_prop(s, "calib_bias", &calib_bias) && calib_bias) { sprintf(sysfs_path, SENSOR_CALIB_BIAS_PATH, dev_num, prefix); sysfs_write_int(sysfs_path, calib_bias); } /* Change buffer length according to the property or use default value */ if (mode == MODE_TRIGGER) { if (sensor_get_prop(s, "buffer_length", &buffer_length)) { buffer_length = BUFFER_LENGTH; } sprintf(sysfs_path, BUFFER_LENGTH_PATH, dev_num); if (sysfs_write_int(sysfs_path, buffer_length) <= 0) { ALOGE("Failed to set buffer length on dev%d", dev_num); } } /* Read name attribute, if available */ sprintf(sysfs_path, NAME_PATH, dev_num); sysfs_read_str(sysfs_path, sensor[s].internal_name, MAX_NAME_SIZE); /* See if we have general offsets and scale values for this sensor */ sprintf(sysfs_path, SENSOR_OFFSET_PATH, dev_num, prefix); sysfs_read_float(sysfs_path, &sensor[s].offset); sprintf(sysfs_path, SENSOR_SCALE_PATH, dev_num, prefix); if (!sensor_get_fl_prop(s, "scale", &scale)) { /* * There is a chip preferred scale specified, * so try to store it in sensor's scale file */ if (sysfs_write_float(sysfs_path, scale) == -1 && errno == ENOENT) { ALOGE("Failed to store scale[%g] into %s - file is missing", scale, sysfs_path); /* Store failed, try to store the scale into channel specific file */ for (c = 0; c < num_channels; c++) { sprintf(sysfs_path, BASE_PATH "%s", dev_num, sensor_catalog[catalog_index].channel[c].scale_path); if (sysfs_write_float(sysfs_path, scale) == -1) ALOGE("Failed to store scale[%g] into %s", scale, sysfs_path); } } } sprintf(sysfs_path, SENSOR_SCALE_PATH, dev_num, prefix); if (!sysfs_read_float(sysfs_path, &scale)) { sensor[s].scale = scale; ALOGV("Scale path:%s scale:%g dev_num:%d\n", sysfs_path, scale, dev_num); } else { sensor[s].scale = 1; /* Read channel specific scale if any*/ for (c = 0; c < num_channels; c++) { sprintf(sysfs_path, BASE_PATH "%s", dev_num, sensor_catalog[catalog_index].channel[c].scale_path); if (!sysfs_read_float(sysfs_path, &scale)) { sensor[s].channel[c].scale = scale; sensor[s].scale = 0; ALOGV( "Scale path:%s " "channel scale:%g dev_num:%d\n", sysfs_path, scale, dev_num); } } } /* Set default scaling - if num_channels is zero, we have one channel */ sensor[s].channel[0].opt_scale = 1; for (c = 1; c < num_channels; c++) sensor[s].channel[c].opt_scale = 1; for (c = 0; c < num_channels; c++) { /* Check the presence of the channel's input_path */ sprintf(sysfs_path, BASE_PATH "%s", dev_num, sensor_catalog[catalog_index].channel[c].input_path); sensor[s].channel[c].input_path_present = (access(sysfs_path, R_OK) != -1); /* Check the presence of the channel's raw_path */ sprintf(sysfs_path, BASE_PATH "%s", dev_num, sensor_catalog[catalog_index].channel[c].raw_path); sensor[s].channel[c].raw_path_present = (access(sysfs_path, R_OK) != -1); } sensor_get_available_frequencies(s); if (sensor_get_mounting_matrix(s, sensor[s].mounting_matrix)) sensor[s].quirks |= QUIRK_MOUNTING_MATRIX; else /* Read ACPI _PLD attributes for this sensor, if there are any */ decode_placement_information(dev_num, num_channels, s); /* * See if we have optional correction scaling factors for each of the * channels of this sensor. These would be expressed using properties * like iio.accel.y.opt_scale = -1. In case of a single channel we also * support things such as iio.temp.opt_scale = -1. Note that this works * for all types of sensors, and whatever transform is selected, on top * of any previous conversions. */ if (num_channels) { for (c = 0; c < num_channels; c++) { ch_name = sensor_catalog[catalog_index].channel[c].name; sprintf(suffix, "%s.opt_scale", ch_name); if (!sensor_get_fl_prop(s, suffix, &opt_scale)) sensor[s].channel[c].opt_scale = opt_scale; } } else { if (!sensor_get_fl_prop(s, "opt_scale", &opt_scale)) sensor[s].channel[0].opt_scale = opt_scale; } populate_descriptors(s, sensor_type); if (sensor[s].internal_name[0] == '\0') { /* * In case the kernel-mode driver doesn't expose a name for * the iio device, use (null)-dev%d as the trigger name... * This can be considered a kernel-mode iio driver bug. */ ALOGW("Using null trigger on sensor %d (dev %d)\n", s, dev_num); strcpy(sensor[s].internal_name, "(null)"); } switch (sensor_type) { case SENSOR_TYPE_ACCELEROMETER: /* Only engage accelerometer bias compensation if really needed */ if (sensor_get_quirks(s) & QUIRK_BIASED) sensor[s].cal_data = calloc(1, sizeof(accel_cal_t)); break; case SENSOR_TYPE_GYROSCOPE: sensor[s].cal_data = malloc(sizeof(gyro_cal_t)); break; case SENSOR_TYPE_MAGNETIC_FIELD: sensor[s].cal_data = malloc(sizeof(compass_cal_t)); break; } sensor[s].max_cal_level = sensor_get_cal_steps(s); /* Select one of the available sensor sample processing styles */ select_transform(s); /* Initialize fields related to sysfs reads offloading */ sensor[s].thread_data_fd[0] = -1; sensor[s].thread_data_fd[1] = -1; sensor[s].acquisition_thread = -1; /* Check if we have a special ordering property on this sensor */ if (sensor_get_order(s, sensor[s].order)) sensor[s].quirks |= QUIRK_FIELD_ORDERING; sensor[s].needs_enable = get_needs_enable(dev_num, sensor_catalog[catalog_index].tag); sensor_count++; return 0; }
parse_switches (j_compress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real) { int argn; char * arg; boolean simple_progressive; char * scansarg = NULL; simple_progressive = FALSE; outfilename = NULL; copyoption = JCOPYOPT_DEFAULT; transformoption.transform = JXFORM_NONE; transformoption.trim = FALSE; transformoption.force_grayscale = FALSE; cinfo->err->trace_level = 0; for (argn = 1; argn < argc; argn++) { arg = argv[argn]; if (*arg != '-') { if (argn <= last_file_arg_seen) { outfilename = NULL; continue; } break; } arg++; if (keymatch(arg, "arithmetic", 1)) { #ifdef C_ARITH_CODING_SUPPORTED cinfo->arith_code = TRUE; #else fprintf(stderr, "%s: sorry, arithmetic coding not supported\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "copy", 1)) { if (++argn >= argc) usage(); if (keymatch(argv[argn], "none", 1)) { copyoption = JCOPYOPT_NONE; } else if (keymatch(argv[argn], "comments", 1)) { copyoption = JCOPYOPT_COMMENTS; } else if (keymatch(argv[argn], "all", 1)) { copyoption = JCOPYOPT_ALL; } else usage(); } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) { static boolean printed_version = FALSE; if (! printed_version) { fprintf(stderr, "Independent JPEG Group's JPEGTRAN, version %s\n%s\n", JVERSION, JCOPYRIGHT); printed_version = TRUE; } cinfo->err->trace_level++; } else if (keymatch(arg, "flip", 1)) { if (++argn >= argc) usage(); if (keymatch(argv[argn], "horizontal", 1)) select_transform(JXFORM_FLIP_H); else if (keymatch(argv[argn], "vertical", 1)) select_transform(JXFORM_FLIP_V); else usage(); } else if (keymatch(arg, "grayscale", 1) || keymatch(arg, "greyscale",1)) { #if TRANSFORMS_SUPPORTED transformoption.force_grayscale = TRUE; #else select_transform(JXFORM_NONE); #endif } else if (keymatch(arg, "maxmemory", 3)) { long lval; char ch = 'x'; if (++argn >= argc) usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (ch == 'm' || ch == 'M') lval *= 1000L; cinfo->mem->max_memory_to_use = lval * 1000L; } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) { #ifdef ENTROPY_OPT_SUPPORTED cinfo->optimize_coding = TRUE; #else fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "outfile", 4)) { if (++argn >= argc) usage(); outfilename = argv[argn]; } else if (keymatch(arg, "progressive", 1)) { #ifdef C_PROGRESSIVE_SUPPORTED simple_progressive = TRUE; #else fprintf(stderr, "%s: sorry, progressive output was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "restart", 1)) { long lval; char ch = 'x'; if (++argn >= argc) usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (lval < 0 || lval > 65535L) usage(); if (ch == 'b' || ch == 'B') { cinfo->restart_interval = (unsigned int) lval; cinfo->restart_in_rows = 0; } else { cinfo->restart_in_rows = (int) lval; } } else if (keymatch(arg, "rotate", 2)) { if (++argn >= argc) usage(); if (keymatch(argv[argn], "90", 2)) select_transform(JXFORM_ROT_90); else if (keymatch(argv[argn], "180", 3)) select_transform(JXFORM_ROT_180); else if (keymatch(argv[argn], "270", 3)) select_transform(JXFORM_ROT_270); else usage(); } else if (keymatch(arg, "scans", 1)) { #ifdef C_MULTISCAN_FILES_SUPPORTED if (++argn >= argc) usage(); scansarg = argv[argn]; #else fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "transpose", 1)) { select_transform(JXFORM_TRANSPOSE); } else if (keymatch(arg, "transverse", 6)) { select_transform(JXFORM_TRANSVERSE); } else if (keymatch(arg, "trim", 3)) { transformoption.trim = TRUE; } else { usage(); } } if (for_real) { #ifdef C_PROGRESSIVE_SUPPORTED if (simple_progressive) jpeg_simple_progression(cinfo); #endif #ifdef C_MULTISCAN_FILES_SUPPORTED if (scansarg != NULL) if (! read_scan_script(cinfo, scansarg)) usage(); #endif } return argn; }
void select_glDrawElements(const pointer_state_t* vtx, GLenum mode, GLuint count, GLenum type, GLvoid * indices) { if (count == 0) return; if (vtx->pointer == NULL) return; GLushort *ind = (GLushort*)indices; GLsizei min, max; getminmax_indices(indices, &max, &min, count); max++; GLfloat *vert = copy_gl_array(vtx->pointer, vtx->type, vtx->size, vtx->stride, GL_FLOAT, 3, 0, max); GLfloat tmp[3]; init_select(); GLfloat zmin=1.0f, zmax=0.0f; for (int i=min; i<max; i++) { select_transform(vert+i*3); if (vert[i*3+2]<zmin) zmin=vert[i*3+2]; if (vert[i*3+2]>zmax) zmax=vert[i*3+2]; } if (zmin<0.0f) zmin = 0.0f; if (zmax>1.0f) zmax = 1.0f; #define FOUND() { \ if (zmin<state.selectbuf.zmin) state.selectbuf.zmin=zmin; \ if (zmax>state.selectbuf.zmax) state.selectbuf.zmax=zmax; \ state.selectbuf.hit = 1; \ free(vert); \ return; \ } for (int i=0; i<count; i++) { switch (mode) { case GL_POINTS: if (select_point_in_viewscreen(vert+ind[i]*3)) FOUND(); break; case GL_LINES: if (i%2==1) { if (select_segment_in_viewscreen(vert+ind[(i-1)]*3, vert+ind[i]*3)) FOUND(); } break; case GL_LINE_STRIP: case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here if (i>0) { if (select_segment_in_viewscreen(vert+ind[(i-1)]*3, vert+ind[i]*3)) FOUND(); } break; case GL_TRIANGLES: if (i%3==2) { if (select_triangle_in_viewscreen(vert+ind[(i-2)]*3, vert+ind[(i-1)]*3, vert+ind[i]*3)) FOUND(); } break; case GL_TRIANGLE_STRIP: if (i>1) { if (select_triangle_in_viewscreen(vert+ind[(i-2)]*3, vert+ind[(i-1)]*3, vert+ind[i]*3)) FOUND(); } break; case GL_TRIANGLE_FAN: if (i>1) { if (select_triangle_in_viewscreen(vert+ind[0]*3, vert+ind[(i-1)]*3, vert+ind[i]*3)) FOUND(); } break; default: return; // Should never go there! } } free(vert); #undef FOUND }
void select_glDrawArrays(const pointer_state_t* vtx, GLenum mode, GLuint first, GLuint count) { if (count == 0) return; if (vtx->pointer == NULL) return; if (state.selectbuf.buffer == NULL) return; GLfloat *vert = copy_gl_array(vtx->pointer, vtx->type, vtx->size, vtx->stride, GL_FLOAT, 3, 0, count+first); GLfloat tmp[3]; GLfloat zmin=1.0f, zmax=0.0f; init_select(); #define FOUND() { \ if (zmin<state.selectbuf.zmin) state.selectbuf.zmin=zmin; \ if (zmax>state.selectbuf.zmax) state.selectbuf.zmax=zmax; \ state.selectbuf.hit = 1; \ free(vert); \ return; \ } // transform the points for (int i=first; i<count+first; i++) { select_transform(vert+i*3); if (vert[i*3+2]<zmin) zmin=vert[i*3+2]; if (vert[i*3+2]>zmax) zmax=vert[i*3+2]; } // intersect with screen now GLfloat *vert2 = vert + first*3; for (int i=0; i<count; i++) { switch (mode) { case GL_POINTS: if (select_point_in_viewscreen(vert2+i*3)) FOUND(); break; case GL_LINES: if (i%2==1) { if (select_segment_in_viewscreen(vert2+(i-1)*3, vert2+i*3)) FOUND(); } break; case GL_LINE_STRIP: case GL_LINE_LOOP: //FIXME: the last "loop" segment is missing here if (i>0) { if (select_segment_in_viewscreen(vert2+(i-1)*3, vert2+i*3)) FOUND(); } break; case GL_TRIANGLES: if (i%3==2) { if (select_triangle_in_viewscreen(vert2+(i-2)*3, vert2+(i-1)*3, vert2+i*3)) FOUND(); } break; case GL_TRIANGLE_STRIP: if (i>1) { if (select_triangle_in_viewscreen(vert2+(i-2)*3, vert2+(i-1)*3, vert2+i*3)) FOUND(); } break; case GL_TRIANGLE_FAN: if (i>1) { if (select_triangle_in_viewscreen(vert2, vert2+(i-1)*3, vert2+i*3)) FOUND(); } break; default: return; // Should never go there! } } free(vert); #undef FOUND }