/** Filtering thread * * Loops until the stream is not active anymore, or an error occurs * * \param handle pointer to OmlMStream to use the filters on (cast as void*) * * \return NULL, inconditionally; shouldn't return in normal operation */ static void* thread_start(void* handle) { OmlMStream* ms = (OmlMStream*)handle; OmlMP* mp = ms->mp; useconds_t usec = (useconds_t)(1000000 * ms->sample_interval); int status = 0; while (1) { usleep(usec); if (!mp_lock(mp)) { if (!mp->active) { mp_unlock(mp); return NULL; // we are done } status = filter_process(ms); mp_unlock(mp); } if (status == -1) { return NULL; // Fatal error --> exit thread } } }
static modulenode_t *_run(moduletree_t *modtree, modulenode_t *modnode) { int next = 1; modulenode_t **child; int i; switch (modnode->type) { case MNTYPE_HEAD: case MNTYPE_MODULE: module_process(modnode); break; case MNTYPE_FILTER: filter_process(modnode); break; case MNTYPE_MERGER: if (!allset(modnode)) { next = 0; break; } merge_process(modnode); break; } if (next == 1) { for (i = 0; i < modnode->childsize; ++i) { _run(modtree, modnode->child[i]); } } }
BOOL filter_image(IMAGE* image, int filter_id) { FILTER filter = create_filter(filter_data[filter_id][0], filter_data[filter_id][1], filter_values[filter_id], filter_data[filter_id][2], filter_data[filter_id][3]); //add_extra_filter(&filter, filter_values[extra_filter_id], filter_data[extra_filter_id][0]*filter_data[extra_filter_id][1]); filter_process(&filter, image); return TRUE; }
static void process_outgoing_single(struct worker_t *self, struct pbuf_t *pb) { struct client_t *c, *cnext; struct client_t *origin = pb->origin; /* reduce pointer deferencing in tight loops */ /* // debug dump if (self->id == 0) { hlog(LOG_DEBUG, "o: %*s", pb->packet_len-2, pb->data); hlog(LOG_DEBUG, "b:%s%s", (pb->flags & F_FROM_UPSTR) ? " from_upstr" : "", (pb->flags & F_FROM_DOWNSTR) ? " from_downstr" : "" ); } */ /* specific tight loops */ if (pb->flags & F_DUPE) { /* Duplicate packet. Don't send, unless client especially wants! */ for (c = self->clients_dupe; (c); c = cnext) { cnext = c->class_next; // client_write() MAY destroy the client object! if (c->state == CSTATE_CONNECTED) send_single(self, c, pb); } /* Check if I have the client which sent this dupe, and * increment it's dupe counter */ /* OPTIMIZE: we walk through all clients for each dupe - how to find it quickly? */ for (c = self->clients; (c); c = c->next) { if (c == origin) { clientaccount_add(c, -1, 0, 0, 0, 0, 0, 1); break; } } return; } if (pb->flags & F_FROM_DOWNSTR) { /* client is from downstream, send to upstreams and peers */ for (c = self->clients_ups; (c); c = cnext) { cnext = c->class_next; // client_write() MAY destroy the client object! if ((c->state == CSTATE_CONNECTED || c->state == CSTATE_COREPEER) && c != origin) send_single(self, c, pb); } } /* packet came from anywhere and is not a dupe - let's go through the * clients who connected us */ for (c = self->clients_other; (c); c = cnext) { cnext = c->class_next; // client_write() MAY destroy the client object! /* Do not send to clients that are not logged in. */ if (c->state != CSTATE_CONNECTED) { //hlog(LOG_DEBUG, "%d/%s: not sending to client: not connected", c->fd, c->username); continue; } /* If not full feed, process filters to see if the packet should be sent. */ if (( (c->flags & CLFLAGS_FULLFEED) != CLFLAGS_FULLFEED) && filter_process(self, c, pb) < 1) { //hlog(LOG_DEBUG, "fd %d: Not fullfeed or not matching filter, not sending.", c->fd); continue; } /* Do not send packet back to the source client. This may reject a packet that came from a socket that got closed a few milliseconds ago and its client_t got recycled on a newly connected client, but if the new client is a long living one, all further packets will be accepted just fine. For packet history dumps this test shall be ignored! Very unlikely check, so check for this last. */ if (c == origin) { //hlog(LOG_DEBUG, "%d: not sending to client: originated from this socketsocket", c->fd); continue; } send_single(self, c, pb); } }