static struct MknnDistEvalInstance multi_distanceEval_new(void *state_distance, MknnDomain *domain_left, MknnDomain *domain_right) { struct State_Multi_Dist *state_dist = state_distance; int64_t length1 = mknn_domain_multiobject_getLength(domain_left); int64_t length2 = mknn_domain_multiobject_getLength(domain_right); if (length1 != state_dist->num_distances) my_log_error( "domain_left is multi-object length %"PRIi64" but multi-distance contains %"PRIi64" distance%s\n", length1, state_dist->num_distances, (state_dist->num_distances == 1) ? "" : "s"); if (length2 != state_dist->num_distances) my_log_error( "domain_right is multi-object length %"PRIi64" but multi-distance contains %"PRIi64" distance%s\n", length2, state_dist->num_distances, (state_dist->num_distances == 1) ? "" : "s"); struct State_Multi_Eval *state = MY_MALLOC(1, struct State_Multi_Eval); state->state_dist = state_dist; state->subdist_evals = MY_MALLOC(state_dist->num_distances, MknnDistanceEval*); for (int64_t i = 0; i < state_dist->num_distances; ++i) { MknnDomain *subLeft = mknn_domain_multiobject_getSubDomain(domain_left, i); MknnDomain *subRight = mknn_domain_multiobject_getSubDomain(domain_right, i); state->subdist_evals[i] = mknn_distance_newDistanceEval( state_dist->distances[i], subLeft, subRight); } struct MknnDistEvalInstance di = { 0 }; di.state_distEval = state; di.func_distanceEval_eval = multi_distanceEval_eval; di.func_distanceEval_release = multi_distanceEval_release; return di; }
int main(int argc, char **argv) { rtmp_state_t st; int to_write; if (argc != 3) { fprintf(stderr, "usage: %s <url> <0|1>\n", argv[0]); return 1; } logger_init("/dev/stderr"); //set_logger_level(LOG_DEBUG); set_logger_level(LOG_INFO); to_write = atoi(argv[2]) ? 1 : 0; st.remote_url = argv[1]; st.flv_path = "dump.flv"; if (rtmp_state_init(&st, to_write)) { my_log_error("rtmp_state_init() failed"); return 1; } if (rtmp_handshake(&st)) { my_log_error("handshake is unsuccessful"); return 1; } my_log_info("handshake is successful"); if (rtmp_send_connect(&st)) { my_log_error("connect failed"); return 1; } if (to_write) { if (rtmp_client_wait_publishing(&st)) return 1; my_log_info("ready to send media"); if (rtmp_send_media(&st)) { my_log_info("error sending media"); return 1; } } else { if (rtmp_client_wait_play(&st)) return 1; my_log_info("ready to play"); if (rtmp_receive_media(&st)) { my_log_info("error getting media"); return 1; } } rtmp_state_free(&st); return 0; }
void leerArchivoDeConfiguracion(int argc, char *argv[]) { char* logMsg = NULL; if (argc < 2) { logMsg = string_from_format( "Debe especificar la ruta al archivo de configuracion, al invocar al programa, por ejemplo: ./Memoria /home/utnso/tp-2015-2c-tpso/Memoria/config_memoria.cfg\n"); puts(logMsg); my_log_error(logMsg); exit(-1); } char* nombreArchivoConfig = nombreArchivoConfig = strdup(argv[1]); uint8_t result = checkearRutaArchivoConfig(nombreArchivoConfig); if (result == -1) { logMsg = string_from_format("Archivo de configuracion no encontrado. Parametro especificado: %s\n", nombreArchivoConfig); puts(logMsg); my_log_error(logMsg); exit(-1); } else { t_config* archivoConfig; archivoConfig = config_create(nombreArchivoConfig); //warning asignacion diferentes tipos configuracion = iniciarArchivoConfig(); configuracion->puertoEscucha = config_get_int_value(archivoConfig, "PUERTO_ESCUCHA"); configuracion->puertoSwap = config_get_int_value(archivoConfig, "PUERTO_SWAP"); configuracion->ipSwap = strdup(config_get_string_value(archivoConfig, "IP_SWAP")); char* nombreMemoria = config_get_string_value(archivoConfig, "NOMBRE_MEMORIA"); configuracion->nombreMemoria = strdup(nombreMemoria != NULL ? nombreMemoria : "NOMBRE_MEMORIA"); configuracion->maximosMarcosPorProceso = config_get_int_value(archivoConfig, "MAXIMO_MARCOS_POR_PROCESO"); configuracion->cantidadMarcos = config_get_int_value(archivoConfig, "CANTIDAD_MARCOS"); configuracion->tamanioMarcos = config_get_int_value(archivoConfig, "TAMANIO_MARCO"); configuracion->entradasTlb = config_get_int_value(archivoConfig, "ENTRADAS_TLB"); if (string_equals(config_get_string_value(archivoConfig, "TLB_HABILITADA"),"SI")){ configuracion->tlbHabilitada=1; } else if (string_equals(config_get_string_value(archivoConfig, "TLB_HABILITADA"),"NO")){ configuracion->tlbHabilitada=0; } configuracion->retardoMemoria = config_get_int_value(archivoConfig, "RETARDO_MEMORIA"); configuracion->algoritmo_reemplazo = strdup(config_get_string_value(archivoConfig, "ALGORITMO_REEMPLAZO")); my_log_info("[INFO]: Archivo de configuracion leido correctamente\n"); logMsg = string_from_format("Archivo de configuracion leido correctamente\n"); puts(logMsg); //config_destroy(archivoConfig); } }
Transform_Def *findTransformDef(const char *code) { if (defs_tr == NULL) my_log_error("no transformations defined\n"); Transform_Def *def = NULL; int64_t i; for (i = 0; i < my_vectorObj_size(defs_tr); ++i) { Transform_Def *d = my_vectorObj_get(defs_tr, i); if (my_string_equals(d->trCode, code)) return d; } my_log_error("unknown transformation %s\n", code); return def; }
MyMapObjObj *my_mapObjObj_new(my_func_compareObj func_compare_keys) { MyMapObjObj *map = MY_MALLOC(1, MyMapObjObj); map->func_compare_keys = func_compare_keys; if (func_compare_keys == NULL) my_log_error("func_compare_keys is null\n"); return map; }
void my_random_intList_noRepetitions(int64_t minValueIncluded, int64_t maxValueNotIncluded, int64_t *array, int64_t sample_size) { int64_t interval_size = maxValueNotIncluded - minValueIncluded; my_assert_greaterInt("random interval", interval_size, 0); if (sample_size > interval_size) my_log_error( "cannot select %"PRIi64" values between %"PRIi64" possible values\n", sample_size, interval_size); if (sample_size > interval_size / 100) { int64_t *ids = my_random_newPermutation(minValueIncluded, maxValueNotIncluded); memcpy(array, ids, sample_size * sizeof(int64_t)); MY_FREE(ids); } else { MY_MUTEX_LOCK(rnd_mutex); internal_ensure_seed(); for (int64_t i = 0; i < sample_size; ++i) { array[i] = minValueIncluded + internal_random_int(interval_size); for (int64_t j = 0; j < i; ++j) { if (array[i] == array[j]) { i--; break; } } } MY_MUTEX_UNLOCK(rnd_mutex); } }
MknnDataset *mknn_datasetLoader_MultiObject(int64_t num_subdatasets, MknnDataset **subdatasets, bool free_subdatasets_on_dataset_release) { struct MultiObjectDataset *data = MY_MALLOC(1, struct MultiObjectDataset); data->num_subdatasets = num_subdatasets; data->subdatasets = MY_MALLOC(num_subdatasets, MknnDataset*); data->free_subdatasets_on_release = free_subdatasets_on_dataset_release; data->num_objects = 0; MknnDomain **subdomains = MY_MALLOC(num_subdatasets, MknnDomain*); for (int64_t i = 0; i < num_subdatasets; ++i) { int64_t size = mknn_dataset_getNumObjects(subdatasets[i]); subdomains[i] = mknn_dataset_getDomain(subdatasets[i]); if (i == 0) { data->num_objects = size; } else if (data->num_objects != size) { my_log_error( "error generating the MULTIOBJECT dataset. Different lengths.\nAll the modalities must contain the same number of objects.\n"); } } if (data->num_objects > 0) data->object_array = MY_MALLOC(data->num_objects, void**); for (int64_t i = 0; i < data->num_objects; ++i) { data->object_array[i] = MY_MALLOC(num_subdatasets, void*); for (int64_t j = 0; j < num_subdatasets; ++j) { data->object_array[i][j] = mknn_dataset_getObject(subdatasets[j], i); } } MknnDomain *multi_domain = mknn_domain_newMultiobject(num_subdatasets, subdomains, false); MknnDataset *new_dataset = mknn_datasetLoader_Custom(data, func_getNumObjects_multiobject, func_getObject_multiobject, NULL, func_releaseDataPointer_multiobject, multi_domain, true); free(subdomains); return new_dataset; }
static double priv_calcularValorIndicador(Distance* fd, char *nomIndicador, int64_t numSamples, int64_t multiplicadorFase) { struct State_Multimetric *es = fd->state_dist; double *sample = computeDistanceSample(es->colQuery, es->colReference, fd, numSamples * multiplicadorFase, "Q", "R"); struct MyDataStats stats = my_math_computeStats(numSamples, sample); struct MyQuantiles quant = my_math_computeQuantiles(numSamples, sample); MY_FREE(sample); double indicador = 0; if (my_string_equals_ignorecase(nomIndicador, "RHO")) indicador = stats.rho; else if (my_string_equals_ignorecase(nomIndicador, "VAR")) indicador = stats.variance; else if (my_string_equals_ignorecase(nomIndicador, "A1")) indicador = quant.a1; else if (my_string_equals_ignorecase(nomIndicador, "A0.5")) indicador = quant.a0_5; else if (my_string_equals_ignorecase(nomIndicador, "A0.1")) indicador = quant.a0_1; else if (my_string_equals_ignorecase(nomIndicador, "A0.01")) indicador = quant.a0_01; else if (my_string_equals_ignorecase(nomIndicador, "A0.001")) indicador = quant.a0_001; else if (my_string_equals_ignorecase(nomIndicador, "A0.0001")) indicador = quant.a0_0001; else if (my_string_equals_ignorecase(nomIndicador, "A0.00001")) indicador = quant.a0_00001; else my_log_error("indicador %s desconocido\n", nomIndicador); return indicador; }
int64_t mknn_dataset_multiobject_getNumSubDatasets( MknnDataset *multiobject_dataset) { if (!mknn_domain_isGeneralDomainMultiObject( mknn_dataset_getDomain(multiobject_dataset))) { my_log_error("dataset must be multiobject\n"); } struct MultiObjectDataset *data = mknn_dataset_custom_getDataPointer( multiobject_dataset); return data->num_subdatasets; }
MknnDataset *mknn_dataset_multiobject_getSubDataset( MknnDataset *multiobject_dataset, int64_t num_subdataset) { if (!mknn_domain_isGeneralDomainMultiObject( mknn_dataset_getDomain(multiobject_dataset))) { my_log_error("dataset must be multiobject\n"); } struct MultiObjectDataset *data = mknn_dataset_custom_getDataPointer( multiobject_dataset); my_assert_indexRangeInt("num_subdataset", num_subdataset, data->num_subdatasets); return data->subdatasets[num_subdataset]; }
int modbus_close_device(modbus_t* context) { if (modbus_flush(context) < 0) { my_log_error("modbus_close_rtu_device"); return -1; } modbus_close(context); modbus_free(context); return 0; }
static int64_t internal_random_int(int64_t maxValueNotIncluded) { my_assert_greaterInt("random_int maxValue", maxValueNotIncluded, 0); int64_t val = 0; if (maxValueNotIncluded <= MAX_RANDOM_31b) val = internal_random_int_31b(); else if (maxValueNotIncluded <= MAX_RANDOM_62b) val = internal_random_int_62b(); else my_log_error("random_int maxValue too large\n"); //TODO: remove bias to small values int64_t rnd = val % maxValueNotIncluded; return rnd; }
modbus_t* modbus_new_rtu_device(const char* serial_port, int slaveAddr) { modbus_t* context = modbus_new_rtu(serial_port, modbus_baud_rate_device_water_cool_boxihua, modbus_parity_device_water_cool_boxihua, modbus_databit_device_water_cool_boxihua, modbus_stopbit_device_water_cool_boxihua); if (context == NULL) { my_log_error("modbus_new_rtu"); return NULL; } #ifdef HAVE_DECL_TIOCSRS485 if (modbus_rtu_set_serial_mode(context, modbus_serial_mode_device_water_cool_boxihua) < 0) { my_log_error("modbus_rtu_set_serial_mode"); return NULL; } #endif if (modbus_set_slave(context, slaveAddr) < 0) { my_log_error("modbus_set_slave"); return NULL; } if (modbus_connect(context) < 0) { my_log_error("modbus_connect"); return NULL; } return context; }
static void multi_dist_build(void *state_distance, const char *id_dist, MknnDistanceParams *params_distance) { struct State_Multi_Dist *state_dist = state_distance; if (mknn_distanceParams_getString(params_distance, "normalization_alpha") != NULL) { double alpha = mknn_distanceParams_getDouble(params_distance, "normalization_alpha"); MknnDataset *dataset = mknn_distanceParams_getObject(params_distance, "normalization_dataset"); if (dataset == NULL) my_log_error( "the dataset must be provided to autonormalize distances\n"); auto_normalization(state_dist, alpha, dataset); } printDetails(state_dist); }
modbus_t* modbus_new_tcp_device() { // ignore this. IP address. modbus_t* pContext = modbus_new_tcp("192.168.1.12", 502); modbus_set_slave(pContext, 2); if (modbus_connect(pContext) < 0) { my_log_error("modbus_connect"); return NULL; } return pContext; }
int rtmp_receive_media(rtmp_state_t *st) { int rc, flags, to_stop; rtmp_message_t *msg; my_packet_t pkt; #ifndef WIN32 sigset_t curr_set, old_set; sigemptyset(&curr_set); sigaddset(&curr_set, SIGINT); #endif signal(SIGINT, &sigint_media_handler); to_stop = 0; global_st = st; while (!to_stop) { rc = rtmp_receive_chunk(st, &msg); if (rc == 1) return 1; if (!rc) continue; flags = 0; switch (msg->type_id) { case RTMP_MSG_AUDIO: flags = PACKET_TYPE_AUDIO; break; case RTMP_MSG_VIDEO: flags = PACKET_TYPE_VIDEO; break; case RTMP_MSG_DATA_AMF0: flags = PACKET_TYPE_METADATA; break; default: break; }; if (flags) { pkt.pts = pkt.dts = msg->timestamp; pkt.stream_index = 0; pkt.flags = flags; pkt.data = msg->body; pkt.size = msg->size; #ifndef WIN32 sigprocmask(SIG_SETMASK, &curr_set, &old_set); #endif if (my_flv_write(st->flv_context, &pkt)) { my_log_error("error writing flv file"); to_stop = 1; } #ifndef WIN32 sigprocmask(SIG_SETMASK, &old_set, &curr_set); #endif } rtmp_message_free(st, msg); } return 0; }