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