Exemple #1
0
void
getClips (JsonReader * reader, GESLayer * layer, GESTrackType type,
    gboolean absolute_paths)
{
  int i;
  json_reader_read_member (reader, "clips");

  g_print ("= clips =\n");

  for (i = 0; i < json_reader_count_elements (reader); i++) {
    json_reader_read_element (reader, i);
    const char *src = getString (reader, "src");
    int start = getInt (reader, "start");
    int in = getInt (reader, "in");
    int dur = getInt (reader, "dur");
    g_print ("Clip: %s (start: %d, in: %d, dur: %d)\n", src, start, in, dur);

    GESClip *clip;

    if (is_in_members (reader, "multi") && getBool (reader, "multi")) {
      g_print ("multi on.\n");
      clip =
          ges_multi_clip_from_path (src, layer, start, in, dur, absolute_paths);
    } else {
      const char *path;
      if (absolute_paths == TRUE) {
        path = src;
      } else {
        path = ges_renderer_get_absolute_path (src);
      }
      clip = ges_clip_from_path (path, layer, start, in, dur, type);
    }

    GESTimeline *tl = ges_layer_get_timeline (layer);
    GList *tracks = ges_timeline_get_tracks (tl);
    GESTrack *trackv = g_list_first (tracks)->data;
    GESTrack *tracka = g_list_last (tracks)->data;

    if (is_in_members (reader, "volume")) {
      double volume = getDouble (reader, "volume");
      GESTrackElement *audioElement =
          ges_clip_find_track_element (clip, tracka, G_TYPE_NONE);
      if (audioElement != NULL) {
        ges_track_element_set_child_properties (audioElement, "volume", volume,
            NULL);
      }
    }

    GESTrackElement *videoElement =
        ges_clip_find_track_element (clip, trackv, G_TYPE_NONE);

    if (videoElement != NULL) {
      if (is_in_members (reader, "x")) {
        int x = getInt (reader, "x");
        ges_track_element_set_child_properties (videoElement, "posx", x, NULL);
      }
      if (is_in_members (reader, "y")) {
        int y = getInt (reader, "y");
        ges_track_element_set_child_properties (videoElement, "posy", y, NULL);
      }
      if (is_in_members (reader, "alpha")) {
        gdouble alpha = getDouble (reader, "alpha");
        ges_track_element_set_child_properties (videoElement, "alpha", alpha,
            NULL);
      }

      if (is_in_members (reader, "size")) {
        gdouble size = getDouble (reader, "size");
        GESUriClipAsset *asset =
            GES_URI_CLIP_ASSET (ges_extractable_get_asset (GES_EXTRACTABLE
                (clip)));
        guint width = ges_asset_get_width (asset);
        guint height = ges_asset_get_height (asset);

        if (width != 0 && height != 0) {
          double dw = width * size;
          double dh = height * size;
          g_print ("%dx%d => * %f => %dx%d\n", width, height, size, (int) dw,
              (int) dh);
          ges_track_element_set_child_properties (videoElement,
              "width", (int) dw, "height", (int) dh, NULL);
        }
      }

      if (is_in_members (reader, "effect")) {
        const char *effect_str = getString (reader, "effect");
        if (strcmp (effect_str, "") != 0) {
          g_print ("Using effect %s", effect_str);
          GESEffect *effect = ges_effect_new (effect_str);
          ges_container_add (GES_CONTAINER (clip),
              GES_TIMELINE_ELEMENT (effect));
        }
      }
    }

    json_reader_end_element (reader);
  }
  json_reader_end_member (reader);
}
Exemple #2
0
bool StringParameterDescriptor::filePathExists() {
  return (getInt(kOfxParamPropStringFilePathExists, 0) == 1);
}
Exemple #3
0
void
render_json (const char *filename)
{
  JsonParser *parser;
  JsonNode *root;
  GError *error;
  parser = json_parser_new ();

  error = NULL;
  json_parser_load_from_file (parser, filename, &error);
  if (error) {
    g_print ("Parsing error `%s':\n %s\n", filename, error->message);
    g_error_free (error);
    g_object_unref (parser);
    exit (0);
  }

  root = json_parser_get_root (parser);

  JsonReader *reader = json_reader_new (root);
  GESTimeline *timeline;

  json_reader_read_member (reader, "composition");

  // comp strings
  const char *name = getString (reader, "name");
  //const char *src_dir = getString (reader, "src-dir");
  //g_print ("Source Directory: %s\nName: %s\n", src_dir, name);

  // comp ints
  int width = getInt (reader, "width");
  int height = getInt (reader, "height");
  int fps = getInt (reader, "fps");

  gboolean transparency = TRUE;

  if (is_in_members (reader, "transparency")) {
    transparency = getBool (reader, "transparency");
  }

  gboolean absolute_paths = FALSE;

  if (is_in_members (reader, "absolute_paths")) {
    absolute_paths = getBool (reader, "absolute_paths");
  }

  g_print ("Resolution: %dx%d, FPS: %d\n", width, height, fps);

  timeline = ges_timeline_new_audio_video ();

  int i;
  json_reader_read_member (reader, "layers");

  for (i = 0; i < json_reader_count_elements (reader); i++) {
    json_reader_read_element (reader, i);

    GESLayer *layer = ges_layer_new ();

    g_object_set (layer, "priority", i, NULL);

    if (is_in_members (reader, "autotransition")) {
      gboolean autotransition = getBool (reader, "autotransition");
      if (autotransition)
        g_print ("Auto Transitions on.\n");
      g_object_set (layer, "auto-transition", autotransition, NULL);
    }

    ges_timeline_add_layer (timeline, layer);

    getClips (reader, layer, GES_TRACK_TYPE_UNKNOWN, absolute_paths);

    json_reader_end_element (reader);
  }
  json_reader_end_member (reader);

  ges_timeline_commit (timeline);

  const gchar *xges_path = g_strconcat ("file://", filename, ".xges", NULL);

  ges_timeline_save_xges (timeline, xges_path);

  //free(xges_path);

  // formats
  GESRendererProfile res =
      { width, height, fps, PROFILE_AAC_H264_QUICKTIME, NULL };
  if (!transparency) {
    g_print ("Deactivating transparency\n");
    res.format = "I420";
  }

  json_reader_read_member (reader, "formats");
  for (i = 0; i < json_reader_count_elements (reader); i++) {
    json_reader_read_element (reader, i);
    const char *format = json_reader_get_string_value (reader);
    json_reader_end_element (reader);
    g_print ("format: %s\n", format);
    EncodingProfile prof = PROFILE_AAC_H264_QUICKTIME;
    if (strcmp (format, "webm") == 0) {
      prof = PROFILE_VORBIS_VP8_WEBM;
    } else if (strcmp (format, "mkv") == 0) {
      prof = PROFILE_VORBIS_H264_MATROSKA;
    } else if (strcmp (format, "mp4") == 0) {
      prof = PROFILE_AAC_H264_QUICKTIME;
    } else if (strcmp (format, "ogg") == 0) {
      prof = PROFILE_VORBIS_THEORA_OGG;
    }
    res.profile = prof;
    ges_renderer_render (timeline, name, &res, absolute_paths);
  }
  json_reader_end_member (reader);

  json_reader_end_member (reader);

  g_object_unref (reader);
  g_object_unref (parser);
}
 FOR(tt, t) {
     long long int n = getInt();
     int i = 2;
     while (data[i] < n) i++;
     printf("%d\n", i);
 }
Exemple #5
0
    void mexFunction(int nlhs, mxArray* plhs[],
                     int nrhs, const mxArray* prhs[])
    {
        // mexPrintf("Number of lhs = %d\n", nlhs);
        // mexPrintf("number of rhs = %d\n", nrhs);
        // create a log writer for error messages if this is the
        // first MATLAB function call
        initLogger();

        // flag specifying the class
        int iclass = getInt(prhs[0]);

        // Hand off to the appropriate routine, based on the
        // value of the first parameter
        switch (iclass) {
        case NO_CLASS:
            ctfunctions(nlhs, plhs, nrhs, prhs);
            break;
        case XML_CLASS:
            xmlmethods(nlhs, plhs, nrhs, prhs);
            break;
        case THERMO_CLASS:
            thermomethods(nlhs, plhs, nrhs, prhs);
            break;
        case PHASE_CLASS:
            phasemethods(nlhs, plhs, nrhs, prhs);
            break;
        case MIXTURE_CLASS:
            mixturemethods(nlhs, plhs, nrhs, prhs);
            break;
        case KINETICS_CLASS:
            kineticsmethods(nlhs, plhs, nrhs, prhs);
            break;
        case TRANSPORT_CLASS:
            transportmethods(nlhs, plhs, nrhs, prhs);
            break;
        case REACTOR_CLASS:
            reactormethods(nlhs, plhs, nrhs, prhs);
            break;
        case REACTORNET_CLASS:
            reactornetmethods(nlhs, plhs, nrhs, prhs);
            break;
        case WALL_CLASS:
            wallmethods(nlhs, plhs, nrhs, prhs);
            break;
        case FLOWDEVICE_CLASS:
            flowdevicemethods(nlhs, plhs, nrhs, prhs);
            break;
        case ONEDIM_CLASS:
            onedimmethods(nlhs, plhs, nrhs, prhs);
            break;
        case SURF_CLASS:
            surfmethods(nlhs, plhs, nrhs, prhs);
            break;
        case FUNC_CLASS:
            funcmethods(nlhs, plhs, nrhs, prhs);
            break;
        default:
            mexPrintf("iclass = %d",iclass);
            //mexErrMsgTxt("unknown class");
        }
    }
Exemple #6
0
void RepoQuery::getAttr(int iCol, Attr& attrs) {
  int val;
  getInt(iCol, val);
  attrs = Attr(val);
}
    return minus ? -r : r;
}

int cmp(const void *p1, const void *p2) {
    return *((int *)p2) - *((int *)p1);
}

int main(void) {
    int n = getInt();
    int totalNumbers = 0;
    int a[MAX_N];
    FOR(i, n) {
        a[totalNumbers] = getInt();
        if (a[totalNumbers] < 0) totalNumbers++;
    }
    long long int x = getInt();

    long long int result = 0;
    if (totalNumbers > 0) {
        if (totalNumbers > x) {
            qsort(a, totalNumbers, sizeof(a[0]), cmp);
            int v = -a[totalNumbers - x];
            result = v * x;
            FORE(i, totalNumbers - x + 1, totalNumbers) result += -a[i] - v;
        } else {
            FOR(i, totalNumbers) result += -a[i];
        }
    }
    printf("%lld\n", result);

bool RegistrySettingsManager::getUINT(const TCHAR *name, UINT *value)
{
  return getInt(name, (int *)value);
}
Exemple #9
0
void Config::loadValues(string country)
{
  
  runtimeBaseDir = getString("common", "runtime_dir", "/usr/share/openalpr/runtime_data");
  
  opencl_enabled = getBoolean("common", "opencl_enabled", false);
  multithreading_cores = getInt("common", "multithreading_cores", 1);

  detection_iteration_increase = getFloat("common", "detection_iteration_increase", 1.1);
  maxPlateWidthPercent = getFloat("common", "max_plate_width_percent", 100);
  maxPlateHeightPercent = getFloat("common", "max_plate_height_percent", 100);

  maxPlateAngleDegrees = getInt("common", "max_plate_angle_degrees", 15);
  
  minPlateSizeWidthPx = getInt(country, "min_plate_size_width_px", 100);
  minPlateSizeHeightPx = getInt(country, "min_plate_size_height_px", 100);
    
  plateWidthMM = getFloat(country, "plate_width_mm", 100);
  plateHeightMM = getFloat(country, "plate_height_mm", 100);
  
  charHeightMM = getFloat(country, "char_height_mm", 100);
  charWidthMM = getFloat(country, "char_width_mm", 100);
  charWhitespaceTopMM = getFloat(country, "char_whitespace_top_mm", 100);
  charWhitespaceBotMM = getFloat(country, "char_whitespace_bot_mm", 100);
  
  templateWidthPx = getInt(country, "template_max_width_px", 100);
  templateHeightPx = getInt(country, "template_max_height_px", 100);
    
  float ocrImagePercent = getFloat("common", "ocr_img_size_percent", 100);
  ocrImageWidthPx = round(((float) templateWidthPx) * ocrImagePercent);
  ocrImageHeightPx = round(((float)templateHeightPx) * ocrImagePercent);

    
  float stateIdImagePercent = getFloat("common", "state_id_img_size_percent", 100);
  stateIdImageWidthPx = round(((float)templateWidthPx) * ocrImagePercent);
  stateIdimageHeightPx = round(((float)templateHeightPx) * ocrImagePercent);

 
  charAnalysisMinPercent = getFloat(country, "char_analysis_min_pct", 0);
  charAnalysisHeightRange = getFloat(country, "char_analysis_height_range", 0);
  charAnalysisHeightStepSize = getFloat(country, "char_analysis_height_step_size", 0);
  charAnalysisNumSteps = getInt(country, "char_analysis_height_num_steps", 0);
 
  segmentationMinBoxWidthPx = getInt(country, "segmentation_min_box_width_px", 0);
  segmentationMinCharHeightPercent = getFloat(country, "segmentation_min_charheight_percent", 0);
  segmentationMaxCharWidthvsAverage = getFloat(country, "segmentation_max_segment_width_percent_vs_average", 0);
  
  plateLinesSensitivityVertical = getFloat(country, "plateline_sensitivity_vertical", 0);
  plateLinesSensitivityHorizontal = getFloat(country, "plateline_sensitivity_horizontal", 0);
  
  ocrLanguage = getString(country, "ocr_language", "none");
  ocrMinFontSize = getInt("common", "ocr_min_font_point", 100);
  
  postProcessMinConfidence = getFloat("common", "postprocess_min_confidence", 100);
  postProcessConfidenceSkipLevel = getFloat("common", "postprocess_confidence_skip_level", 100);
  postProcessMaxSubstitutions = getInt("common", "postprocess_max_substitutions", 100);
  postProcessMinCharacters = getInt("common", "postprocess_min_characters", 100);
  postProcessMaxCharacters = getInt("common", "postprocess_max_characters", 100);
  
  debugGeneral = 	getBoolean("debug", "general",		false);
  debugTiming = 	getBoolean("debug", "timing",		false);
  debugStateId = 	getBoolean("debug", "state_id",		false);
  debugPlateLines = 	getBoolean("debug", "plate_lines", 	false);
  debugPlateCorners = 	getBoolean("debug", "plate_corners", 	false);
  debugCharRegions = 	getBoolean("debug", "char_regions", 	false);
  debugCharSegmenter = 	getBoolean("debug", "char_segment", 	false);
  debugCharAnalysis =	getBoolean("debug", "char_analysis",	false);
  debugColorFiler = 	getBoolean("debug", "color_filter", 	false);
  debugOcr = 		getBoolean("debug", "ocr", 		false);
  debugPostProcess = 	getBoolean("debug", "postprocess", 	false);
  debugShowImages = 	getBoolean("debug", "show_images",	false);
  debugPauseOnFrame = 	getBoolean("debug", "pause_on_frame",	false);
  
}
int TeSQLitePortal::getInt(const string& s)
{
	return getInt(getColumnIndex(s));
}
void bridge_message(struct mosquitto *mosq, int sd, struct device *dev, char *msg)
{
	char md_id[DEVICE_MD_ID_SIZE + 1];
	struct module *md;
	struct device *target_dev;
	int code, i;

	if (config.debug > 2) printf("Bridge - message: %s\n", msg);

	if (!getInt(&msg, &code)) {
		if (config.debug > 1) printf("MQTT - Invalid data.\n");
		return;
	}

	switch (code) {
		case PROTO_ERROR:
		case PROTO_ACK:
		case PROTO_NACK:
		case PROTO_ST_TIMEOUT:
		case PROTO_DEVICE:
			return;
		case PROTO_ST_ALIVE:
			if (!getInt(&msg, &code))
				return;
			if (dev->modules == code)
				return;
			dev->modules = code;
			// no return here is purposeful
		case PROTO_ST_MODULES_UP:	// Modules Update
			if (dev->type == DEVICE_TYPE_NODE) {
				// Message from a serial device
				if (dev->md_deps->type == MODULE_SERIAL && bridge.serial_ready) {
					snprintf(gbuf, GBUF_SIZE, "%s%s,%d", SERIAL_INIT_MSG, dev->id, PROTO_GET_MODULES);
					serialport_printlf(sd, gbuf);
				}
				// Message from a MQTT device
				else if (dev->md_deps->type == MODULE_MQTT) {
					snprintf(gbuf, GBUF_SIZE, "%s,%d", bridge.id, PROTO_GET_MODULES);
					mqtt_publish(mosq, dev->topic, gbuf);
					return;
				}
			}
			return;
		case PROTO_GET_MODULES:
			// Message from a MQTT device
			if (dev->md_deps->type == MODULE_MQTT) {
				for (md = bridge.module; md != NULL; md = md->next) {
					snprintf(gbuf, GBUF_SIZE, "%s,%d,%s,%s,%d", bridge.id, PROTO_MODULE, md->id, md->device, md->enabled);
					mqtt_publish(mosq, dev->topic, gbuf);
				}
			}
			return;
		case PROTO_GET_DEVICES:
			// Message from a MQTT device
			if (dev->md_deps->type == MODULE_MQTT) {
				for (i = 0; i < bridge.devices_len; i++) {
					target_dev = &bridge.devices[i];
					snprintf(gbuf, GBUF_SIZE, "%s,%d,%s,%d,%d"
						, bridge.id, PROTO_DEVICE, target_dev->id, target_dev->modules, target_dev->alive);
					mqtt_publish(mosq, dev->topic, gbuf);
				}
			}
			return;
		case PROTO_SAVE_DEVICE:
			target_dev = device_get(&bridge, msg);
			if (!target_dev)
				return;
			if (config.debug > 1) {
				printf("Saving device:\n");
				device_print_device(target_dev);
			}
			device_save(&bridge, config.devices_folder, target_dev);
			return;
	}

	if (!getString(&msg, md_id, DEVICE_MD_ID_SIZE, ',')) {
		if (config.debug > 1) printf("Missing module id - code: %d\n", code);
		return;
	}
	if (!device_isValid_md_id(md_id)) {
		if (config.debug > 1) printf("Invalid module id - code: %d\n", code);
		return;
	}

	md = device_get_module(&bridge, md_id);
	if (code == PROTO_MODULE) {
		if (!md) {
			if (device_add_module(&bridge, md_id, dev->id) == -1) {
				run = 0;
				return;
			}
			if (config.debug > 1) {
				md = device_get_module(&bridge, md_id);
				printf("New Module:\n");
				device_print_module(md);
			}
		}
		return;
	}

	if (!md)
		return;
	target_dev = device_get(&bridge, md->device);
	if (!target_dev) {
		fprintf(stderr, "Error: Orphan module.\n");
		device_remove_module(&bridge, md_id);
		return;
	}

	switch (code) {
		case PROTO_GET_MODULE:
			// Message from a MQTT device
			if (dev->md_deps->type == MODULE_MQTT) {
				snprintf(gbuf, GBUF_SIZE, "%s,%d,%s,%s,%d", bridge.id, PROTO_MODULE, md->id, md->device, md->enabled);
				mqtt_publish(mosq, dev->topic, gbuf);
			}
			return;
		case PROTO_MD_GET_TOPIC:
			// Message from a MQTT device
			if (dev->md_deps->type == MODULE_MQTT) {
				snprintf(gbuf, GBUF_SIZE, "%s,%d,%s,%s", bridge.id, PROTO_MD_TOPIC, md->id, md->topic);
				mqtt_publish(mosq, dev->topic, gbuf);
			}
			return;
		case PROTO_MD_SET_TOPIC:
		case PROTO_MD_TOPIC:
			code = device_set_md_topic(md, msg);
			if (code == -1) {		// Memory problem
				run = 0;
				return;
			}
			if (code == 0) {		// Module topic changed
				snprintf(gbuf, GBUF_SIZE, "%d,%s,%s", PROTO_MD_TOPIC, md->id, md->topic);
				mqtt_publish(mosq, bridge.status_topic, gbuf);
			}
			return;
		case PROTO_MD_RAW:
			mqtt_publish(mosq, md->topic, msg);
			return;
		case PROTO_MD_TO_RAW:
			// Target module at serial
			if (target_dev->md_deps->type == MODULE_SERIAL && bridge.serial_ready) {
				snprintf(gbuf, GBUF_SIZE, "%s%s,%d,%s,%s", SERIAL_INIT_MSG, target_dev->id, PROTO_MD_TO_RAW, md->id, msg);
				serialport_printlf(sd, gbuf);
			}
			// Target module at MQTT
			else if (target_dev->md_deps->type == MODULE_MQTT) {
				snprintf(gbuf, GBUF_SIZE, "%s,%d,%s,%s", bridge.id, PROTO_MD_TO_RAW, md->id, msg);
				mqtt_publish(mosq, target_dev->topic, gbuf);
			}
			else if (!strcmp(md->device, bridge.id)) {
				if (md->type == MODULE_SCRIPT) {
					code = run_script(config.scripts_folder, msg, gbuf, GBUF_SIZE, config.debug);
					if (code == -1) {
						run = 0;
					}
					else if (code == 1) {
						mqtt_publish(mosq, md->topic, "0");	
					}
					else if (code == 0) {
						if (strlen(gbuf) > 0) {
							if (config.debug > 1) printf("Script output:\n-\n%s\n-\n", gbuf);
							mqtt_publish(mosq, md->topic, gbuf);
						} else {
							mqtt_publish(mosq, md->topic, "1");
						}
					}
				}
				else if (md->type == MODULE_BANDWIDTH) {
					if (bandwidth) {
						if (mqtt_publish_bandwidth(mosq, md->topic) == -1)
							run = 0;
					}
				}
				else if (md->type == MODULE_SERIAL) {
					snprintf(gbuf, GBUF_SIZE, "%d", bridge.serial_ready);
					mqtt_publish(mosq, md->topic, gbuf);
				}
			}
			return;
		case PROTO_MD_ENABLE:			//TODO: implement
		case PROTO_MD_GET_ENABLE:		//TODO: implement
		case PROTO_MD_SET_ENABLE: 		//TODO: implement
			return;
		default:
			if (config.debug > 2) printf("Bridge - code: %d - Not treated.\n", code);
	}
}
Exemple #12
0
int
main(int argc, char *argv[])
{
    int numKeyFlags;            /* Counts -f, -k, and -p options */
    int flags, shmid, segSize;
    unsigned int perms;
    long lkey;
    key_t key;
    int opt;                    /* Option character from getopt() */

    /* Parse command-line options and arguments */

    numKeyFlags = 0;
    flags = 0;

    while ((opt = getopt(argc, argv, "cf:k:px")) != -1) {
        switch (opt) {
        case 'c':
            flags |= IPC_CREAT;
            break;

        case 'f':               /* -f pathname */
            key = ftok(optarg, 1);
            if (key == -1)
                errExit("ftok");
            numKeyFlags++;
            break;

        case 'k':               /* -k key (octal, decimal or hexadecimal) */
            if (sscanf(optarg, "%li", &lkey) != 1)
                cmdLineErr("-k option requires a numeric argument\n");
            key = lkey;
            numKeyFlags++;
            break;

        case 'p':
            key = IPC_PRIVATE;
            numKeyFlags++;
            break;

        case 'x':
            flags |= IPC_EXCL;
            break;

        default:
            usageError(argv[0], NULL);
        }
    }

    if (numKeyFlags != 1)
        usageError(argv[0], "Exactly one of the options -f, -k, "
                            "or -p must be supplied\n");

    if (optind >= argc)
        usageError(argv[0], "Size of segment must be specified\n");

    segSize = getLong(argv[optind], GN_ANY_BASE, "seg-size");

    perms = (argc <= optind + 1) ? (S_IRUSR | S_IWUSR) :
                getInt(argv[optind + 1], GN_BASE_8, "octal-perms");

    shmid = shmget(key, segSize, flags | perms);
    if (shmid == -1)
        errExit("shmget");

    printf("%d\n", shmid);      /* On success, display shared mem. id */
    exit(EXIT_SUCCESS);
}
 int ShadowCalculation_Impl::calculationFrequency() const {
   boost::optional<int> value = getInt(OS_ShadowCalculationFields::CalculationFrequency,true);
   OS_ASSERT(value);
   return value.get();
 }
 int ShadowCalculation_Impl::maximumFiguresInShadowOverlapCalculations() const {
   boost::optional<int> value = getInt(OS_ShadowCalculationFields::MaximumFiguresinShadowOverlapCalculations,true);
   OS_ASSERT(value);
   return value.get();
 }
Exemple #15
0
void RepoQuery::getId(int iCol, Id& id) {
  int val;
  getInt(iCol, val);
  id = Id(val);
}
Exemple #16
0
 boost::optional<int> ProgramControl_Impl::numberofThreadsAllowed() const {
   return getInt(OS_ProgramControlFields::NumberofThreadsAllowed,true);
 }
Exemple #17
0
void RepoQuery::getOffset(int iCol, Offset& offset) {
  int val;
  getInt(iCol, val);
  offset = Offset(val);
}
Exemple #18
0
int
main(int argc, char *argv[])
{
    struct utmpx ut;
    char *devName;

    if (argc < 2 || strcmp(argv[1], "--help") == 0)
        usageErr("%s username [sleep-time]\n", argv[0]);

    /* Initialize login record for utmp and wtmp files */

    memset(&ut, 0, sizeof(struct utmpx));
    ut.ut_type = USER_PROCESS;          /* This is a user login */
    strncpy(ut.ut_user, argv[1], sizeof(ut.ut_user));
    if (time((time_t *) &ut.ut_tv.tv_sec) == -1)
        errExit("time");                /* Stamp with current time */
    ut.ut_pid = getpid();

    /* Set ut_line and ut_id based on the terminal associated with
       'stdin'. This code assumes terminals named "/dev/[pt]t[sy]*".
       The "/dev/" dirname is 5 characters; the "[pt]t[sy]" filename
       prefix is 3 characters (making 8 characters in all). */

    devName = ttyname(STDIN_FILENO);
    if (devName == NULL)
        errExit("ttyname");
    if (strlen(devName) <= 8)           /* Should never happen */
        fatal("Terminal name is too short: %s", devName);

    strncpy(ut.ut_line, devName + 5, sizeof(ut.ut_line));
    strncpy(ut.ut_id, devName + 8, sizeof(ut.ut_id));

    printf("Creating login entries in utmp and wtmp\n");
    printf("        using pid %ld, line %.*s, id %.*s\n",
            (long) ut.ut_pid, (int) sizeof(ut.ut_line), ut.ut_line,
            (int) sizeof(ut.ut_id), ut.ut_id);

    setutxent();                        /* Rewind to start of utmp file */
    if (pututxline(&ut) == NULL)        /* Write login record to utmp */
        errExit("pututxline");
    updwtmpx(_PATH_WTMP, &ut);          /* Append login record to wtmp */

    /* Sleep a while, so we can examine utmp and wtmp files */

    sleep((argc > 2) ? getInt(argv[2], GN_NONNEG, "sleep-time") : 15);

    /* Now do a "logout"; use values from previously initialized 'ut',
       except for changes below */

    ut.ut_type = DEAD_PROCESS;          /* Required for logout record */
    time((time_t *) &ut.ut_tv.tv_sec);  /* Stamp with logout time */
    memset(&ut.ut_user, 0, sizeof(ut.ut_user));
                                        /* Logout record has null username */

    printf("Creating logout entries in utmp and wtmp\n");
    setutxent();                        /* Rewind to start of utmp file */
    if (pututxline(&ut) == NULL)        /* Overwrite previous utmp record */
        errExit("pututxline");
    updwtmpx(_PATH_WTMP, &ut);          /* Append logout record to wtmp */

    endutxent();
    exit(EXIT_SUCCESS);
}
Exemple #19
0
void RepoQuery::getBool(int iCol, bool& b) {
  int val;
  getInt(iCol, val);
  b = bool(val);
}
Exemple #20
0
RenderPass RenderStage::createRenderPassFromJson(const JSONValue& renderPassJSON)
{
    GraphicSystem& graphicSystem = renderer.getGraphicSystem();

    RenderPass renderPass;
    auto clearColorJSON = renderPassJSON.getJSONValue("clearColor");
    auto colorWriteJSON = renderPassJSON.getJSONValue("colorWrite");
    auto depthWriteJSON = renderPassJSON.getJSONValue("depthWrite");
    auto renderTargetLayerJSON = renderPassJSON.getJSONValue("renderTargetLayer");
    auto flagsJSON = renderPassJSON.getJSONValue("flags");

    if(!clearColorJSON.isNull())
        renderPass.clearColor = clearColorJSON.getVector4();
    if(!colorWriteJSON.isNull())
        renderPass.colorWrite = colorWriteJSON.getBool();
    if(!depthWriteJSON.isNull())
        renderPass.depthWrite = depthWriteJSON.getBool();
    if(!renderTargetLayerJSON.isNull())
        renderPass.renderTargetLayer = renderTargetLayerJSON.getInt();
    if(!flagsJSON.isNull())
    {
        unsigned int flags = 0;
        for(unsigned int i = 0; i < flagsJSON.getSize(); ++i)
        {
            if(flagsJSON.getJSONArrayItem(i).getString().compare("CLEAR_COLOR") == 0)
                flags |= CLEAR_COLOR;
            if(flagsJSON.getJSONArrayItem(i).getString().compare("CLEAR_DEPTH") == 0)
                flags |= CLEAR_DEPTH;
        }
        renderPass.flags = flags;
    }

    auto viewPortJSON = renderPassJSON.getJSONValue("viewPort");
    if(!viewPortJSON.isNull())
    {
        FixedArray<int, 4> viewPort = viewPortJSON.getInt4();
        renderPass.viewPort.set(viewPort[0], viewPort[1], viewPort[2], viewPort[3]);
    }
    else
        renderPass.viewPort = renderer.getScreenViewPort();

    auto renderTargetJSON = renderPassJSON.getJSONValue("renderTarget");
    renderPass.renderTarget = graphicSystem.createRenderTarget(renderTargetJSON);

    auto shaderPasses = renderPassJSON.getJSONValue("shaderPasses");

    if(!shaderPasses.isNull())
    {
        for(unsigned int i = 0; i < shaderPasses.getSize(); ++i)
        {
            auto shaderPassJSON = shaderPasses.getJSONArrayItem(i);
            auto programJSON = shaderPassJSON.getJSONValue("shaderProgram");
            auto vertexDataJSON = shaderPassJSON.getJSONValue("vertexData");
            auto rasterStateJSON = shaderPassJSON.getJSONValue("rasterState");
            auto shaderParameterBlocksJSON = shaderPassJSON.getJSONValue("shaderParameterBlocks");
            auto texturesJSON = shaderPassJSON.getJSONValue("textures");
            ShaderPass shaderPass;

            if(!vertexDataJSON.isNull())
            {
                if(vertexDataJSON.getString().compare("fullScreenQuad") == 0)
                    shaderPass.vertexData = renderer.getFullScreenQuad();
            }
            if(!rasterStateJSON.isNull())
            {
                auto blendFunctionJSON = rasterStateJSON.getJSONValue("blendFunction");
                auto compareFunctionJSON = rasterStateJSON.getJSONValue("compareFunction");
                auto cullFaceJSON = rasterStateJSON.getJSONValue("cullFace");
                auto blendState = !blendFunctionJSON.isNull() ? BlendState(true, enumFromString<BlendFunction>(blendFunctionJSON.getString())) : BlendState(false, BlendFunction::Replace);
                auto compareState = !compareFunctionJSON.isNull() ? CompareState(true, enumFromString<CompareFunction>(compareFunctionJSON.getString())) : CompareState(false, CompareFunction::Never);
                auto cullState = !cullFaceJSON.isNull() ? CullState(true, enumFromString<CullFace>(cullFaceJSON.getString())) : CullState(false, CullFace::Back);
                shaderPass.rasterState = RasterState(blendState, compareState, cullState);
            }

            if(!shaderParameterBlocksJSON.isNull())
            {
                for(unsigned int j = 0; j < shaderParameterBlocksJSON.getSize(); ++j)
                {
                    ShaderParameterBlock* block = graphicSystem.createShaderParameterBlock(shaderParameterBlocksJSON.getJSONArrayItem(j));
                    if(block)
                        shaderPass.shaderParameterBlocks.pushBack(block);
                }
            }
            if(!texturesJSON.isNull())
            {
                for(unsigned int j = 0; j < texturesJSON.getSize(); ++j)
                {
                    Texture* texture = graphicSystem.createTexture(texturesJSON.getJSONArrayItem(j));
                    if(texture)
                        shaderPass.textures.pushBack(texture);
                }
            }

            if(!programJSON.isNull())
                shaderPass.program = graphicSystem.createShaderProgram(programJSON);

            renderPass.shaderPasses.pushBack(shaderPass);
        }
    }
    return renderPass;
}
Exemple #21
0
long long int comb[MAX_C][MAX_C];
long long int data[MAX_C];

char c = 0;
long long int getInt() {
    long long int r = 0;
    while (!(c >= '0' && c <= '9')) c = getc_unlocked(stdin);
    while (c >= '0' && c <= '9') {
        r = r * 10 + (c - '0');
        c = getc_unlocked(stdin);
    }
    return r;
}


int main(void) {
    FOR(i, MAX_C) {
        comb[i][0] = comb[i][i] = 1;
        FORE(j, 1, i) comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
        data[i] = comb[i][i >> 1];
    }

    int t = getInt();
    FOR(tt, t) {
        long long int n = getInt();
        int i = 2;
        while (data[i] < n) i++;
        printf("%d\n", i);
    }
}
 unsigned RunPeriodControlSpecialDays_Impl::duration() const
 {
   boost::optional<int> result = getInt(OS_RunPeriodControl_SpecialDaysFields::Duration, true);
   OS_ASSERT(result);
   return *result;
 }
int CameraParameters::getPreviewFrameRate() const
{
    return getInt(KEY_PREVIEW_FRAME_RATE);
}
Exemple #24
0
		int parse( char * data, int n )
		{
			w32::Lock lock( &critSec );
			PROFILE;
			
			//int a[512];
			//int nAlive = 0;
			int k=0,mode=0;
			char * b = data;
			while ( k < n )
			{
				//fprintf( stderr, "$ %d %s\n", k, &b[k] );
				if ( strstr( &b[k], "#bundle" ) )
				{
					mode = 0;
					/// moved, see below
					//listener.startBundle();
					
					// ok, we'll skip 'all the seconds there ever were'
					k += 16;
				}
				else
				{
					Packet packet = {0};
					k += parsePacketHeader( &b[k], packet );
					//printf("p %d\t'%s'\t'%s'\t'%s'\n",packet.len,packet.head,packet.cmd,packet.pinfo);

					// cursor or object ?
					if ( ! strcmp( packet.head, "/tuio/2Dobj" ) )
					{
						//
						// this hack keeps our objects alive -
						// we only start a bundle for objects, 
						// sending the cursors to the current bundle:
						//
						if ( mode == 0 )
							listener.startBundle();
						mode = 1;
					} 
					else
					if ( ! strcmp( packet.head, "/tuio/2Dcur" ) )
					{
						mode = 2;
					}
					
					// check the cmd:
					if ( ! strcmp( packet.cmd, "set" ) )
					{
						Object o = {0};
						o.type = mode;
						k += parseSet( &b[k], &o, mode );
						listener.call( o );
					}
					else
					if ( ! strcmp( packet.cmd, "fseq" ) )
					{
						int s = 0;
						k += getInt( &b[k], s );
						if ( seq > s )
						{
							//fprintf( stderr, "!!!seq  %d > %d\n", seq,s );
						}
						seq = s;
					}
					else
					if ( ! strcmp( packet.cmd, "alive" ) )
					{
						int na = strlen(packet.pinfo) - 2; // skip ',s'
						if ( na > 0 )
						{
							for ( int i=0; i<na; i++ )
							{
								int a = 0;
								k += getInt( &b[k], a );
								listener.call( a );
							}
						}
					}
				}			
			}
			return n;
		}