void __init
inithfc(struct IsdnCardState *cs)
{
init_send(&cs->bcs[0]);
init_send(&cs->bcs[1]);
cs->bc_l1_ops = &hfc_l1_ops;
mode_hfc(cs->bcs, 0, 0);
mode_hfc(cs->bcs + 1, 0, 0);
}
void __init
inithfc(struct IsdnCardState *cs)
{
init_send(&cs->bcs[0]);
init_send(&cs->bcs[1]);
cs->BC_Send_Data = &hfc_fill_fifo;
cs->bcs[0].BC_SetStack = setstack_hfc;
cs->bcs[1].BC_SetStack = setstack_hfc;
cs->bcs[0].BC_Close = close_hfcstate;
cs->bcs[1].BC_Close = close_hfcstate;
mode_hfc(cs->bcs, 0, 0);
mode_hfc(cs->bcs + 1, 0, 0);
}
void broadcast(vrp_problem *vrp, int *tids, int jobs)
{
int s_bufid;
if (jobs == 0) return;
s_bufid = init_send(DataInPlace);
send_int_array(&vrp->dist.wtype, 1);
send_int_array(&vrp->vertnum, 1);
send_int_array(&vrp->depot, 1);
send_int_array(&vrp->capacity, 1);
send_int_array(vrp->demand, (int)vrp->vertnum);
if (vrp->dist.wtype != _EXPLICIT){ /* not EXPLICIT */
send_dbl_array(vrp->dist.coordx, vrp->vertnum);
send_dbl_array(vrp->dist.coordy, vrp->vertnum);
if ((vrp->dist.wtype == _EUC_3D) || (vrp->dist.wtype == _MAX_3D) ||
(vrp->dist.wtype == _MAN_3D))
send_dbl_array(vrp->dist.coordz, vrp->vertnum);
}
else{ /* EXPLICIT */
send_int_array(vrp->dist.cost, (int)vrp->edgenum);
}
msend_msg(tids, jobs, VRP_BROADCAST_DATA);
freebuf(s_bufid);
}
int default_send(struct ir_remote *remote, struct ir_ncode *code)
{
/* things are easy, because we only support one mode */
if (drv.send_mode != LIRC_MODE_PULSE)
return (0);
if (drv.features & LIRC_CAN_SET_SEND_CARRIER) {
unsigned int freq;
freq = remote->freq == 0 ? DEFAULT_FREQ : remote->freq;
if (default_ioctl(LIRC_SET_SEND_CARRIER, &freq) == -1) {
logprintf(LIRC_ERROR, "could not set modulation frequency");
logperror(LIRC_ERROR, NULL);
return (0);
}
}
if (drv.features & LIRC_CAN_SET_SEND_DUTY_CYCLE) {
unsigned int duty_cycle;
duty_cycle = remote->duty_cycle == 0 ? 50 : remote->duty_cycle;
if (default_ioctl(LIRC_SET_SEND_DUTY_CYCLE, &duty_cycle) == -1) {
logprintf(LIRC_ERROR, "could not set duty cycle");
logperror(LIRC_ERROR, NULL);
return (0);
}
}
if (!init_send(remote, code))
return (0);
if (write_send_buffer(drv.fd) == -1) {
logprintf(LIRC_ERROR, "write failed");
logperror(LIRC_ERROR, NULL);
return (0);
}
return (1);
}
int send_cg_data_u(sym_environment *env, int sender)
{
#if defined(COMPILE_IN_TM) && defined(COMPILE_IN_LP) && defined(COMPILE_IN_CG)
int i;
tm_prob *tm = env->tm;
tm->cgp = (cg_prob **) malloc(tm->par.max_active_nodes*sizeof(cg_prob *));
#pragma omp parallel for
for (i = 0; i < tm->par.max_active_nodes; i++){
tm->lpp[i]->cgp = tm->cgp[i] = (cg_prob *) calloc(1, sizeof(cg_prob));
tm->cgp[i]->par = env->par.cg_par;
tm->cgp[i]->draw_graph = env->dg_tid;
#ifdef USE_SYM_APPLICATION
CALL_USER_FUNCTION( user_send_cg_data(env->user,
&(tm->lpp[i]->cgp->user)) );
#endif
}
#else
int s_bufid;
s_bufid = init_send(DataInPlace);
send_char_array((char *)(&env->par.cg_par), sizeof(cg_params));
send_int_array(&env->dg_tid, 1);
#ifdef USE_SYM_APPLICATION
CALL_USER_FUNCTION( user_send_cg_data(env->user, NULL) );
#endif
send_msg(sender, CG_DATA);
freebuf(s_bufid);
#endif
return(FUNCTION_TERMINATED_NORMALLY);
}
static ssize_t lirc_write(struct file * file,
const char * buf,
size_t n,
loff_t * pos)
{
int i;
int retval;
if(n%sizeof(lirc_t) || (n/sizeof(lirc_t)) > WBUF_LEN)
return(-EINVAL);
retval = verify_area(VERIFY_READ, buf, n);
if (retval)
return retval;
copy_from_user(tx_buf, buf, n);
i = 0;
n/=sizeof(lirc_t);
init_send();
while (1) {
if (i >= n)
break;
if (tx_buf[i])
send_pulse(tx_buf[i]);
i++;
if (i >= n)
break;
if (tx_buf[i])
send_space(tx_buf[i]);
i++;
}
terminate_send(tx_buf[i-1]);
return n;
}
int send_cp_data_u(sym_environment *env, int sender)
{
#if defined(COMPILE_IN_TM) && defined(COMPILE_IN_CP)
int i;
tm_prob *tm = env->tm;
tm->cpp = (cut_pool **) malloc(env->par.tm_par.max_cp_num*sizeof(cut_pool *));
for (i = 0; i < env->par.tm_par.max_cp_num; i++){
tm->cpp[i] = (cut_pool *) calloc(1, sizeof(cut_pool));
tm->cpp[i]->par = env->par.cp_par;
#ifdef USE_SYM_APPLICATION
CALL_USER_FUNCTION( user_send_cp_data(env->user, &env->tm->cpp[i]->user) );
#endif
}
#else
int s_bufid;
s_bufid = init_send(DataInPlace);
send_char_array((char *)(&env->par.cp_par), sizeof(cp_params));
#ifdef USE_SYM_APPLICATION
CALL_USER_FUNCTION( user_send_cp_data(env->user, NULL) );
#endif
send_msg(sender, CP_DATA);
freebuf(s_bufid);
#endif
return(FUNCTION_TERMINATED_NORMALLY);
}
static int try_connect(struct rtmp_stream *stream)
{
#ifndef FILE_TEST
blog(LOG_INFO, "Connecting to RTMP URL %s...", stream->path.array);
if (!RTMP_SetupURL2(&stream->rtmp, stream->path.array,
stream->key.array))
return OBS_OUTPUT_BAD_PATH;
RTMP_EnableWrite(&stream->rtmp);
set_rtmp_dstr(&stream->rtmp.Link.pubUser, &stream->username);
set_rtmp_dstr(&stream->rtmp.Link.pubPasswd, &stream->password);
stream->rtmp.Link.swfUrl = stream->rtmp.Link.tcUrl;
set_rtmp_str(&stream->rtmp.Link.flashVer,
"FMLE/3.0 (compatible; FMSc/1.0)");
stream->rtmp.m_outChunkSize = 4096;
stream->rtmp.m_bSendChunkSizeInfo = true;
stream->rtmp.m_bUseNagle = true;
if (!RTMP_Connect(&stream->rtmp, NULL))
return OBS_OUTPUT_CONNECT_FAILED;
if (!RTMP_ConnectStream(&stream->rtmp, 0))
return OBS_OUTPUT_INVALID_STREAM;
blog(LOG_INFO, "Connection to %s successful", stream->path.array);
#endif
return init_send(stream);
}
void lp_close(lp_prob *p)
{
#ifndef COMPILE_IN_LP
int s_bufid;
/* Send back the timing data for the whole algorithm */
s_bufid = init_send(DataInPlace);
send_char_array((char *)&p->comp_times, sizeof(node_times));
send_msg(p->tree_manager, LP__TIMING);
freebuf(s_bufid);
#else
#pragma omp critical (timing_update)
{
p->tm->comp_times.communication += p->comp_times.communication;
p->tm->comp_times.lp += p->comp_times.lp;
p->tm->comp_times.separation += p->comp_times.separation;
p->tm->comp_times.fixing += p->comp_times.fixing;
p->tm->comp_times.pricing += p->comp_times.pricing;
p->tm->comp_times.strong_branching += p->comp_times.strong_branching;
}
#endif
#ifdef COMPILE_IN_CG
cg_close(p->cgp);
#endif
#ifndef COMPILE_IN_TM
free_lp(p);
#endif
}
static int iguana_send(struct ir_remote *remote, struct ir_ncode *code)
{
int retval = 0;
uint32_t freq;
/* set the carrier frequency if necessary */
freq = htonl(remote->freq);
if (remote->freq != currentCarrier &&
remote->freq >= 25000 && remote->freq <= 100000 &&
daemonTransaction(IG_DEV_SETCARRIER, &freq, sizeof(freq)))
currentCarrier = remote->freq;
if (init_send(remote, code))
{
int length, x;
lirc_t *signals;
uint32_t *igsignals;
length = send_buffer.wptr;
signals = send_buffer.data;
igsignals = (uint32_t*)malloc(sizeof(uint32_t) * length);
if (igsignals != NULL)
{
iguanaPacket request, response = NULL;
/* must pack the data into a unit32_t array */
for(x = 0; x < length; x++)
{
igsignals[x] = signals[x] & PULSE_MASK;
if (signals[x] & PULSE_BIT)
igsignals[x] |= IG_PULSE_BIT;
}
/* construct a request and send it to the daemon */
request = iguanaCreateRequest(IG_DEV_SEND,
sizeof(uint32_t) * length,
igsignals);
if (iguanaWriteRequest(request, sendConn))
{
/* response will only come back after the device has
* transmitted */
response = iguanaReadResponse(sendConn, 10000);
if (! iguanaResponseIsError(response))
{
retval = 1;
}
iguanaFreePacket(response);
}
/* free the packet and the data */
iguanaFreePacket(request);
}
}
return retval;
}
void INTERMED_ERROR(char *window_name, int old_msgtag,
int receiver, int msgtag)
{
int s_bufid;
s_bufid = init_send(DataInPlace);
send_char_array(window_name, MAX_NAME_LENGTH);
send_int_array(&old_msgtag, 1);
send_msg(receiver, msgtag);
freebuf(s_bufid);
}
void lp_exit(lp_prob *p)
{
int s_bufid;
s_bufid = init_send(DataInPlace);
send_msg(p->tree_manager, SOMETHING_DIED);
freebuf(s_bufid);
comm_exit();
exit(-1);
}
void cg_initialize(cg_prob *p, int master_tid)
{
#ifndef COMPILE_IN_CG
int bytes, msgtag;
#if defined(COMPILE_IN_TM) && defined(COMPILE_IN_LP)
int s_bufid, r_bufid, info;
#endif
#endif
#if !defined(COMPILE_IN_TM) || !defined(COMPILE_IN_LP)
int r_bufid, s_bufid = 0;
#endif
/*------------------------------------------------------------------------
* Receive the problem data
*------------------------------------------------------------------------*/
#ifdef COMPILE_IN_CG
p->master = master_tid;
#else
/* We only need to do this part if the CG is running as a separate process*/
/* Otherwise, all of this setup is done in the master in the function */
/* pack_cg_data_u()*/
/* set stdout to be line buffered */
setvbuf(stdout, (char *)NULL, _IOLBF, 0);
register_process();
r_bufid = receive_msg(ANYONE, MASTER_TID_INFO);
bufinfo(r_bufid, &bytes, &msgtag, &p->tree_manager);
receive_int_array(&p->master, 1);
receive_int_array(&p->proc_index, 1);
freebuf(r_bufid);
#endif
#if !defined(COMPILE_IN_TM) || !defined(COMPILE_IN_LP) || \
!defined(COMPILE_IN_CG)
/* This part, we only need to do if we are not running in full serial mode*/
s_bufid = init_send(DataInPlace);
send_msg(p->master, REQUEST_FOR_CG_DATA);
freebuf(s_bufid);
receive_cg_data_u(p);
#endif
(void) used_time(&p->tt);
}
void ServerNetworkComm::send_frame_rejected( TCPConnection::Ptr client,
const string & frameid,
const URI & sender,
const std::string & reason )
{
SignalFrame frame("frame_rejected", sender, CLIENT_ROOT_PATH);
SignalOptions & options = frame.options();
options.add( "frameid", frameid );
options.add( "reason", reason );
init_send( client, frame );
}
int iguana_send(struct ir_remote *remote, struct ir_ncode *code)
{
int retval = 0;
if (init_send(remote, code))
{
int length, x;
lirc_t *signals;
uint32_t *igsignals;
length = send_buffer.wptr;
signals = send_buffer.data;
igsignals = (uint32_t*)malloc(sizeof(uint32_t) * length);
if (igsignals != NULL)
{
iguanaPacket request, response = NULL;
/* must pack the data into a unit32_t array */
for(x = 0; x < length; x++)
{
igsignals[x] = signals[x] & PULSE_MASK;
if (signals[x] & PULSE_BIT)
igsignals[x] |= IG_PULSE_BIT;
}
/* construct a request and send it to the daemon */
request = iguanaCreateRequest(IG_DEV_SEND,
sizeof(uint32_t) * length,
igsignals);
if (iguanaWriteRequest(request, sendConn))
{
/* response will only come back after the device has
* transmitted */
response = iguanaReadResponse(sendConn, 10000);
if (! iguanaResponseIsError(response))
{
remote->last_code = code;
retval = 1;
}
iguanaFreePacket(response);
}
/* free the packet and the data */
iguanaFreePacket(request);
}
}
return retval;
}
int audio_send(struct ir_remote *remote, struct ir_ncode *code)
{
int length;
lirc_t *signals;
int flags;
char completed;
lirc_t freq;
static lirc_t prevfreq = 0;
if (!init_send(remote, code))
return 0;
length = send_buffer.wptr;
signals = send_buffer.data;
if (length <= 0 || signals == NULL) {
LOGPRINTF(1, "nothing to send");
return 0;
}
/* set completed pipe to non blocking */
flags = fcntl(completedPipe[0], F_GETFL, 0);
fcntl(completedPipe[0], F_SETFL, flags | O_NONBLOCK);
/* remove any unwanted completed bytes */
while (read(completedPipe[0], &completed, sizeof(completed)) == 1) ;
/* set completed pipe to blocking */
fcntl(completedPipe[0], F_SETFL, flags & ~O_NONBLOCK);
/* write carrier frequency */
freq = remote->freq ? remote->freq : DEFAULT_FREQ;
write(sendPipe[1], &freq, sizeof(freq));
if (freq != prevfreq) {
prevfreq = freq;
logprintf(LOG_INFO, "Using carrier frequency %i", freq);
}
/* write signals to sendpipe */
if (write(sendPipe[1], signals, length * sizeof(lirc_t)) == -1) {
logprintf(LOG_ERR, "write failed");
logperror(LOG_ERR, "write()");
return 0;
}
/* wait for the callback to signal us that all signals are written */
read(completedPipe[0], &completed, sizeof(completed));
return 1;
}
static int uirt2_send(struct ir_remote *remote, struct ir_ncode *code)
{
int i, length;
unsigned long delay;
const lirc_t *signals;
int res = 0;
if (!init_send(remote, code)) {
return 0;
}
length = send_buffer_length();
signals = send_buffer_data();
if (length <= 0 || signals == NULL) {
LOGPRINTF(1, "nothing to send");
return 0;
}
LOGPRINTF(1, "Trying REMSTRUC1 transmission");
res = uirt2_send_mode2_struct1(dev, remote, signals, length);
if (!res && (length < 48)) {
LOGPRINTF(1, "Using RAW transission");
res = uirt2_send_mode2_raw(dev, remote, signals, length);
}
if (!res) {
logprintf(LIRC_ERROR, "uirt2_send: remote not supported");
} else {
LOGPRINTF(1, "uirt2_send: succeeded");
}
/*
* Some devices send the sequence in the background. Wait for
* the sequence to complete before returning in order to avoid
* disturbing DTR which is used by certain hardware revisions
* to enable the builtin emitter. We wait 1.1 times the expected
* time in order to handle any differences between the device and
* our clock.
*/
delay = remote->min_remaining_gap;
for (i = 0; i < length; i++) {
delay += signals[i];
}
delay = (delay * 11) / 10;
usleep (delay);
return res;
}
int cg_send_cut(cut_data *new_cut, int *num_cuts, int *alloc_cuts,
cut_data ***cuts)
{
#ifdef COMPILE_IN_CG
int i;
cut_data *tmp_cut;
for (i = 0; i < *num_cuts; i++){
if (new_cut->type != (*cuts)[i]->type ||
new_cut->size != (*cuts)[i]->size ||
new_cut->rhs != (*cuts)[i]->rhs){
continue;
}
if (!new_cut->coef){
return(0);
}
if (memcmp(new_cut->coef, (*cuts)[i]->coef,
new_cut->size) == 0){
return(0);
}
}
if (new_cut->name != CUT__DO_NOT_SEND_TO_CP)
new_cut->name = CUT__SEND_TO_CP;
tmp_cut = (cut_data *) malloc (sizeof(cut_data));
memcpy((char *)tmp_cut, (char *)new_cut, sizeof(cut_data));
if (new_cut->size >0){
tmp_cut->coef = (char *) malloc (new_cut->size * sizeof(char));
memcpy((char *)tmp_cut->coef, (char *)new_cut->coef,
new_cut->size * sizeof(char));
}
REALLOC((*cuts), cut_data *, (*alloc_cuts), (*num_cuts + 1), BB_BUNCH);
(*cuts)[(*num_cuts)++] = tmp_cut;
#else
int s_bufid;
if (new_cut->name != CUT__DO_NOT_SEND_TO_CP)
new_cut->name = CUT__SEND_TO_CP;
s_bufid = init_send(DataInPlace);
pack_cut(new_cut);
send_msg(p->cur_sol.lp, PACKED_CUT);
freebuf(s_bufid);
#endif
return(1);
}
void ServerNetworkComm::send_message( TCPConnection::Ptr client,
const string & message,
LogMessage::Type type )
{
SignalFrame frame("message", SERVER_CORE_PATH, CLIENT_LOG_PATH);
SignalOptions & options = frame.options();
if(type == LogMessage::INVALID)
type = LogMessage::INFO;
options.add("type", LogMessage::Convert::instance().to_str(type));
options.add("text", message);
init_send( client, frame );
}
static int try_connect(struct rtmp_stream *stream)
{
if (dstr_is_empty(&stream->path)) {
warn("URL is empty");
return OBS_OUTPUT_BAD_PATH;
}
info("Connecting to RTMP URL %s...", stream->path.array);
memset(&stream->rtmp.Link, 0, sizeof(stream->rtmp.Link));
if (!RTMP_SetupURL(&stream->rtmp, stream->path.array))
return OBS_OUTPUT_BAD_PATH;
RTMP_EnableWrite(&stream->rtmp);
set_rtmp_dstr(&stream->rtmp.Link.pubUser, &stream->username);
set_rtmp_dstr(&stream->rtmp.Link.pubPasswd, &stream->password);
stream->rtmp.Link.swfUrl = stream->rtmp.Link.tcUrl;
set_rtmp_str(&stream->rtmp.Link.flashVer,
"FMLE/3.0 (compatible; OBS Studio; FMSc/1.0)");
RTMP_AddStream(&stream->rtmp, stream->key.array);
for (size_t idx = 1;; idx++) {
obs_encoder_t *encoder = obs_output_get_audio_encoder(
stream->output, idx);
const char *encoder_name;
if (!encoder)
break;
encoder_name = obs_encoder_get_name(encoder);
RTMP_AddStream(&stream->rtmp, encoder_name);
}
stream->rtmp.m_outChunkSize = 4096;
stream->rtmp.m_bSendChunkSizeInfo = true;
stream->rtmp.m_bUseNagle = true;
if (!RTMP_Connect(&stream->rtmp, NULL))
return OBS_OUTPUT_CONNECT_FAILED;
if (!RTMP_ConnectStream(&stream->rtmp, 0))
return OBS_OUTPUT_INVALID_STREAM;
info("Connection to %s successful", stream->path.array);
return init_send(stream);
}
int default_send(struct ir_remote *remote, struct ir_ncode *code)
{
/* things are easy, because we only support one mode */
if (drv.send_mode != LIRC_MODE_PULSE)
return (0);
if (!init_send(remote, code))
return (0);
if (write_send_buffer(drv.fd) == -1) {
logprintf(LIRC_ERROR, "write failed");
logperror(LIRC_ERROR, NULL);
return (0);
}
return (1);
}
void ServerNetworkComm::init_send( TCPConnection::Ptr client, SignalFrame & frame )
{
if( is_not_null(client) )
{
client->send( frame,
boost::bind( &ServerNetworkComm::callback_send,
this,
client,
asio::placeholders::error
)
);
}
else // if the connection is null, broadcast the frame
{
std::map<TCPConnection::Ptr, ClientInfo>::iterator it = m_clients.begin();
for( ; it != m_clients.end() ; ++it )
init_send( it->first, frame );
}
}
void wait_for_you_can_die(dg_prob *dgp, FILE *write_to)
{
int bufid, s_bufid, bytes, msgtag, sender;
FREE(dgp->windows);
/* invoke the Igd_QuitAll function */
spprint(write_to, "Igd_QuitAll\n");
if (dgp->waiting_to_die == 2 * TRUE)
exit(0);
while (TRUE){
receive_msg(ANYONE, ANYTHING);
bufinfo(bufid, &bytes, &msgtag, &sender);
if (msgtag != CTOI_YOU_CAN_DIE){
s_bufid = init_send(DataInPlace);
send_msg(sender, ITOC_APPLICATION_KILLED);
freebuf(s_bufid);
}else{
exit(0);
}
}
}
int init_draw_graph_u(sym_environment *env)
{
if (env->par.do_draw_graph){ /*start up the graphics window*/
int s_bufid;
if (env->par.dg_machine_set){
spawn(env->par.dg_exe, (char **)NULL, env->par.dg_debug | TaskHost,
env->par.dg_machine, 1, &env->dg_tid);
}else{
spawn(env->par.dg_exe, (char **)NULL, env->par.dg_debug, (char *)NULL, 1,
&env->dg_tid);
}
s_bufid = init_send(DataInPlace);
send_char_array((char *)&env->par.dg_par, sizeof(dg_params));
send_msg(env->dg_tid, DG_DATA);
freebuf(s_bufid);
#ifdef USE_SYM_APPLICATION
if (env->dg_tid)
CALL_USER_FUNCTION( user_init_draw_graph(env->user, env->dg_tid) );
#endif
}
return(FUNCTION_TERMINATED_NORMALLY);
}
static int uirt2_send(struct ir_remote *remote,struct ir_ncode *code)
{
int length;
lirc_t *signals;
int res = 0;
if(!init_send(remote,code)) {
return 0;
}
length = send_buffer.wptr;
signals = send_buffer.data;
if (length <= 0 || signals == NULL) {
LOGPRINTF(1,"nothing to send");
return 0;
}
LOGPRINTF(1, "Trying REMSTRUC1 transmission");
res = uirt2_send_mode2_struct1(dev, remote,
signals, length);
if (!res && (length < 48)) {
LOGPRINTF(1, "Using RAW transission");
res = uirt2_send_mode2_raw(dev, remote,
signals, length);
}
if (!res) {
logprintf(LOG_ERR,
"uirt2_send: remote not supported");
} else {
LOGPRINTF(1, "uirt2_send: succeeded");
}
return res;
}
int send_lp_data_u(sym_environment *env, int sender)
{
#if defined(COMPILE_IN_TM) && defined(COMPILE_IN_LP)
int i;
tm_prob *tm = env->tm;
tm->par.max_active_nodes = env->par.tm_par.max_active_nodes;
#ifdef _OPENMP
omp_set_dynamic(FALSE);
omp_set_num_threads(tm->par.max_active_nodes);
#else
tm->par.max_active_nodes = 1;
#endif
tm->lpp = (lp_prob **) malloc(tm->par.max_active_nodes * sizeof(lp_prob *));
#pragma omp parallel for
for (i = 0; i < tm->par.max_active_nodes; i ++){
tm->lpp[i] = (lp_prob *) calloc(1, sizeof(lp_prob));
tm->lpp[i]->proc_index = i;
tm->lpp[i]->par = env->par.lp_par;
if ((tm->lpp[i]->has_ub = env->has_ub)){
tm->lpp[i]->ub = env->ub;
}else{
env->ub = - (MAXDOUBLE / 2);
}
if (env->par.multi_criteria){
if ((tm->lpp[i]->has_mc_ub = env->has_mc_ub)){
tm->lpp[i]->mc_ub = env->mc_ub;
tm->lpp[i]->obj[0] = env->obj[0];
tm->lpp[i]->obj[1] = env->obj[1];
}else{
env->mc_ub = - (MAXDOUBLE / 2);
}
tm->lpp[i]->utopia[0] = env->utopia[0];
tm->lpp[i]->utopia[1] = env->utopia[1];
}
tm->lpp[i]->draw_graph = env->dg_tid;
tm->lpp[i]->base = *(env->base);
tm->lpp[i]->mip = env->mip;
#ifdef USE_SYM_APPLICATION
CALL_USER_FUNCTION( user_send_lp_data(env->user, &(tm->lpp[i]->user)) );
#endif
}
#else
int s_bufid;
s_bufid = init_send(DataInPlace);
send_char_array((char *)(&env->par.lp_par), sizeof(lp_params));
send_char_array(&env->has_ub, 1);
if (env->has_ub)
send_dbl_array(&env->ub, 1);
if (env->par.multi_crtieria){
send_char_array(&env->has_mc_ub, 1);
if (env->has_mc_ub){
send_dbl_array(&env->mc_ub, 1);
send_dbl_array(env->obj, 2);
}
send_dbl_array(env->utopia, 2);
}
send_int_array(&env->dg_tid, 1);
send_int_array(&env->base->varnum, 1);
if (env->base->varnum){
send_int_array(env->base->userind, env->base->varnum);
}
send_int_array(&env->base->cutnum, 1);
if (env->mip){
MIPdesc *mip = env->mip;
char has_desc = TRUE;
char has_colnames = FALSE;
send_char_array(&has_desc, 1);
send_int_array(&(mip->m), 1);
send_int_array(&(mip->n), 1);
send_int_array(&(mip->nz), 1);
send_char_array(&(mip->obj_sense), 1);
send_dbl_array(&(mip->obj_offset), 1);
send_int_array(mip->matbeg, mip->n);
send_int_array(mip->matind, mip->nz);
send_dbl_array(mip->matval, mip->nz);
send_dbl_array(mip->obj, mip->n);
if (env->par.multi_criteria){
send_dbl_array(mip->obj, mip->n);
send_dbl_array(mip->obj2, mip->n);
}
send_dbl_array(mip->rhs, mip->m);
send_char_array(mip->sense, mip->m);
send_dbl_array(mip->rngval, mip->m);
send_dbl_array(mip->ub, mip->n);
send_dbl_array(mip->lb, mip->n);
send_char_array(mip->is_int, mip->n);
if (mip->colname){
int i;
has_colnames = TRUE;
send_char_array(&has_colnames, 1);
for (i = 0; i < mip->n; i++){
send_char_array(mip->colname[i], 8);
}
}else{
send_char_array(&has_colnames, 1);
}
}else{
char has_desc = FALSE;
send_char_array(&has_desc, 1);
}
#ifdef USE_SYM_APPLICATION
CALL_USER_FUNCTION( user_send_lp_data(env->user, NULL) );
#endif
send_msg(sender, LP_DATA);
freebuf(s_bufid);
#endif
return(FUNCTION_TERMINATED_NORMALLY);
}
static int try_connect(struct rtmp_stream *stream)
{
if (dstr_is_empty(&stream->path)) {
warn("URL is empty");
return OBS_OUTPUT_BAD_PATH;
}
info("Connecting to RTMP URL %s...", stream->path.array);
memset(&stream->rtmp.Link, 0, sizeof(stream->rtmp.Link));
if (!RTMP_SetupURL(&stream->rtmp, stream->path.array))
return OBS_OUTPUT_BAD_PATH;
RTMP_EnableWrite(&stream->rtmp);
dstr_copy(&stream->encoder_name, "FMLE/3.0 (compatible; obs-studio/");
#ifdef HAVE_OBSCONFIG_H
dstr_cat(&stream->encoder_name, OBS_VERSION);
#else
dstr_catf(&stream->encoder_name, "%d.%d.%d",
LIBOBS_API_MAJOR_VER,
LIBOBS_API_MINOR_VER,
LIBOBS_API_PATCH_VER);
#endif
dstr_cat(&stream->encoder_name, "; FMSc/1.0)");
set_rtmp_dstr(&stream->rtmp.Link.pubUser, &stream->username);
set_rtmp_dstr(&stream->rtmp.Link.pubPasswd, &stream->password);
set_rtmp_dstr(&stream->rtmp.Link.flashVer, &stream->encoder_name);
stream->rtmp.Link.swfUrl = stream->rtmp.Link.tcUrl;
RTMP_AddStream(&stream->rtmp, stream->key.array);
for (size_t idx = 1;; idx++) {
obs_encoder_t *encoder = obs_output_get_audio_encoder(
stream->output, idx);
const char *encoder_name;
if (!encoder)
break;
encoder_name = obs_encoder_get_name(encoder);
RTMP_AddStream(&stream->rtmp, encoder_name);
}
stream->rtmp.m_outChunkSize = 4096;
stream->rtmp.m_bSendChunkSizeInfo = true;
stream->rtmp.m_bUseNagle = true;
#ifdef _WIN32
win32_log_interface_type(stream);
#endif
if (!RTMP_Connect(&stream->rtmp, NULL))
return OBS_OUTPUT_CONNECT_FAILED;
if (!RTMP_ConnectStream(&stream->rtmp, 0))
return OBS_OUTPUT_INVALID_STREAM;
info("Connection to %s successful", stream->path.array);
return init_send(stream);
}
int default_send(struct ir_remote *remote,struct ir_ncode *code)
{
lirc_t remaining_gap;
/* things are easy, because we only support one mode */
if(hw.send_mode!=LIRC_MODE_PULSE)
return(0);
#if !defined(SIM_SEND) || defined(DAEMONIZE)
if(hw.features&LIRC_CAN_SET_SEND_CARRIER)
{
unsigned int freq;
freq=remote->freq==0 ? 38000:remote->freq;
if(ioctl(hw.fd,LIRC_SET_SEND_CARRIER,&freq)==-1)
{
logprintf(LOG_ERR,"could not set modulation "
"frequency");
logperror(LOG_ERR,NULL);
return(0);
}
}
if(hw.features&LIRC_CAN_SET_SEND_DUTY_CYCLE)
{
unsigned int duty_cycle;
duty_cycle=remote->duty_cycle==0 ? 50:remote->duty_cycle;
if(ioctl(hw.fd,LIRC_SET_SEND_DUTY_CYCLE,&duty_cycle)==-1)
{
logprintf(LOG_ERR,"could not set duty cycle");
logperror(LOG_ERR,NULL);
return(0);
}
}
#endif
remaining_gap=remote->remaining_gap;
if(!init_send(remote,code)) return(0);
#if !defined(SIM_SEND) || defined(DAEMONIZE)
if(remote->last_code!=NULL)
{
struct timeval current;
unsigned long usecs;
gettimeofday(¤t,NULL);
usecs=time_left(¤t,&remote->last_send,remaining_gap*2);
if(usecs>0) usleep(usecs);
}
#endif
if(write_send_buffer(hw.fd,code->length,code->signals)==-1)
{
logprintf(LOG_ERR,"write failed");
logperror(LOG_ERR,NULL);
return(0);
}
else
{
gettimeofday(&remote->last_send,NULL);
remote->last_code=code;
#if defined(SIM_SEND) && !defined(DAEMONIZE)
printf("space %lu\n",(unsigned long) remote->remaining_gap);
#endif
}
return(1);
}
static int tira_send (struct ir_remote *remote, struct ir_ncode *code)
{
int retval = 0;
unsigned int freq;
unsigned char *sendtable;
if ((deviceflags & 1) == 0)
{
logprintf(LOG_ERR, "this device cannot send ir signals!");
return(0);
}
if (hw.rec_mode != LIRC_MODE_LIRCCODE)
{
logprintf(LOG_ERR, "can't send ir signals in timing mode!");
return(0);
}
/* set the carrier frequency if necessary */
freq = remote->freq;
if(freq == 0) freq = DEFAULT_FREQ;
logprintf(LOG_INFO, "modulation freq %d Hz",freq);
freq=2000000/freq; /* this will be the clock word */
if (freq > 255) freq = 255;
if (!init_send(remote, code)) return(0);
int length,i,s;
lirc_t *signals;
char idx;
int tmp;
length = send_buffer.wptr;
signals = send_buffer.data;
sendtable = malloc(length);
if (sendtable == NULL) return retval;
memset(sendtable,-1,length);
/* Create burst space array for tira */
int bsa[12];
memset(&bsa,0,sizeof(bsa));
for (i = 0; i < length; i++)
{
idx = -1;
tmp = signals[i] / 8;
/* Find signal length in table */
for (s = 0; s < 12; s++)
if (bsa[s] == tmp)
{
idx = s;
break;
}
if (idx==-1)
for (s = 0; s < 12; s++)
if ((tmp < bsa[s]+(freq/16)) &&
(tmp > bsa[s]-(freq/16)))
{
idx = s;
break;
}
if (idx == -1)
{
/* Add a new entry into bsa table */
for (s = 0; s < 12; s++)
{
if (bsa[s] == 0)
{
bsa[s] = tmp;
idx = s;
break;
}
}
}
if (idx == -1)
{
logprintf(LOG_ERR, "can't send ir signal with "
"more than 12 different timings");
return retval;
}
sendtable[i] = idx;
}
tmp=0;
for (i = 0; i < length; i+=2)
{
s = sendtable[i] * 16;
if (i < length-1) s += sendtable[i+1]; else s+=15;
sendtable[tmp] = s;
tmp++;
}
unsigned char *wrtbuf;
wrtbuf = malloc(length+28);
if (wrtbuf == NULL) return retval;
wrtbuf[0]='I';
wrtbuf[1]='X';
wrtbuf[2]=freq;
wrtbuf[3]=0; /* reserved */
for (i=0; i<12; i++)
{
wrtbuf[4+i*2] = (bsa[i] & 0xFFFF) >> 8;
wrtbuf[5+i*2] = bsa[i] & 0xFF;
}
for (i = 0; i < tmp; i++) wrtbuf[28+i]=sendtable[i];
length = 28+tmp;
if (device_type == 'i')
{
i = length;
if (write (hw.fd, wrtbuf, 1) != 1) i = 0;
if (i != 0)
{
usleep(200000);
if (write (hw.fd, &wrtbuf[1], length-1) != length-1)
{
i = 0;
}
}
} else i = write (hw.fd, wrtbuf, length);
if (i != length) logprintf(LOG_ERR, failwrite); else
{
usleep(200000);
i = read (hw.fd, wrtbuf, 3);
if (strncmp((char *) wrtbuf, "OIX", 3) == 0) retval = 1;
else logprintf(LOG_ERR, "no response from device");
}
free(wrtbuf);
free(sendtable);
return retval;
}
void ServerNetworkComm::send_frame_to_client( SignalFrame & signal,
const string & clientid )
{
init_send( get_connection(clientid), signal );
}
