Пример #1
0
static int
get_event(char *host)
{
	struct timeval tv;
	cmyth_conn_t event;

	if ((event=cmyth_conn_connect_event(host, 6543,
					    16*1024, 4096)) == NULL) {
		return -1;
	}

	tv.tv_sec = 1;
	tv.tv_usec = 0;

	if (cmyth_event_select(event, &tv) > 0) {
		cmyth_event_t e;
		char data[128];

		memset(data, 0, sizeof(data));

		e = cmyth_event_get(event, data, sizeof(data));

		printf("Event: %d '%s'\n", e, data);
	}

	ref_release(event);

	return 0;
}
Пример #2
0
static void*
event_loop(void *arg)
{
	intptr_t i = (intptr_t)arg;
	char buf[128];
	cmyth_event_t next;
	int done = 0;
	cmyth_conn_t event;
	cmyth_conn_t control;
	cmyth_proglist_t list;

	debug("%s(): event loop started\n", __FUNCTION__);

	pthread_mutex_lock(&mutex);

	pthread_detach(pthread_self());

	if (!conn[i].used) {
		pthread_mutex_unlock(&mutex);
		return NULL;
	}

	event = conn[i].event;
	control = conn[i].control;
	list = conn[i].list;

	pthread_mutex_unlock(&mutex);

	while (!done) {
		next = cmyth_event_get(event, buf, 128);

		pthread_mutex_lock(&mutex);

		switch (next) {
		case CMYTH_EVENT_CLOSE:
			ref_release(control);
			ref_release(list);
			ref_release(event);
			done = 1;
			break;
		case CMYTH_EVENT_RECORDING_LIST_CHANGE:
			ref_release(list);
			list = cmyth_proglist_get_all_recorded(control);
			conn[i].list = list;
			parse_progs(conn+i);
			break;
		default:
			break;
		}

		pthread_mutex_unlock(&mutex);
	}

	return NULL;
}
Пример #3
0
static void*
cmyth_chain_event_loop(void *data)
{
	int oldstate;
	struct event_loop_args *args = (struct event_loop_args*)data;
	cmyth_chain_t chain = args->chain;
	cmyth_recorder_t rec = args->rec;
	cmyth_recorder_t new_rec;

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s(): thread started!\n", __FUNCTION__);

	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);

	chain->chain_event = cmyth_conn_connect_event(rec->rec_server,
						      rec->rec_port,
						      16*1024, 4096);

	if (chain->chain_event == NULL) {
		return NULL;
	}

	new_rec = cmyth_conn_get_recorder(rec->rec_conn, rec->rec_id);

	chain->chain_thread_rec = new_rec;

	ref_release(chain);
	ref_release(rec);

	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);

	while (1) {
		cmyth_event_t next;
		char buf[256];

		next = cmyth_event_get(chain->chain_event, buf, sizeof(buf));

		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);

		switch (next) {
		case CMYTH_EVENT_LIVETV_CHAIN_UPDATE:
			cmyth_dbg(CMYTH_DBG_DEBUG,
				  "%s(): chain update %s\n", __FUNCTION__, buf);
			cmyth_chain_update(chain, new_rec, buf);
			break;
		default:
			break;
		}

		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
	}

	return NULL;
}