FileFilterList::FileFilterList(docstring const & qt_style_filter)
{
// FIXME UNICODE
string const filter = to_utf8(qt_style_filter)
+ (qt_style_filter.empty() ? string() : ";;")
+ to_utf8(_("All Files "))
#if defined(_WIN32)
+ ("(*.*)");
#else
+ ("(*)");
#endif
// Split data such as "TeX documents (*.tex);;LyX Documents (*.lyx)"
// into individual filters.
static lyx::regex const separator_re(";;");
string::const_iterator it = filter.begin();
string::const_iterator const end = filter.end();
while (true) {
match_results<string::const_iterator> what;
if (!lyx::regex_search(it, end, what, separator_re)) {
parse_filter(string(it, end));
break;
}
// Everything from the start of the input to
// the start of the match.
parse_filter(string(what[-1].first, what[-1].second));
// Increment the iterator to the end of the match.
it += distance(it, what[0].second);
}
}
static int
parse_config(gnc_t gnc, void *closure)
{
int c;
char *token;
c = gnc(closure);
if(c < 2)
return -1;
while(c >= 0) {
c = skip_whitespace(c, gnc, closure);
if(c == '\n' || c == '#') {
c = skip_to_eol(c, gnc, closure);
continue;
}
if(c < 0)
break;
c = getword(c, &token, gnc, closure);
if(c < -1)
return -1;
if(strcmp(token, "in") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &input_filters);
} else if(strcmp(token, "out") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &output_filters);
} else if(strcmp(token, "redistribute") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &redistribute_filters);
} else if(strcmp(token, "interface") == 0) {
struct network_conf *nconf;
nconf = parse_nconf(gnc, closure);
if(nconf == NULL)
return -1;
add_nconf(nconf, &network_confs);
} else {
return -1;
}
free(token);
}
return 1;
}
void DeckBuilder::StartFilter() {
filter_type = mainGame->cbCardType->getSelected();
filter_type2 = mainGame->cbCardType2->getItemData(mainGame->cbCardType2->getSelected());
filter_lm = mainGame->cbLimit->getSelected();
if(filter_type == 1) {
filter_attrib = mainGame->cbAttribute->getItemData(mainGame->cbAttribute->getSelected());
filter_race = mainGame->cbRace->getItemData(mainGame->cbRace->getSelected());
filter_atk = parse_filter(mainGame->ebAttack->getText(), &filter_atktype);
filter_def = parse_filter(mainGame->ebDefense->getText(), &filter_deftype);
filter_lv = parse_filter(mainGame->ebStar->getText(), &filter_lvtype);
filter_scl = parse_filter(mainGame->ebScale->getText(), &filter_scltype);
}
FilterCards();
}
/*
=================
G_RemoveIP_f
=================
*/
void G_RemoveIP_f(edict_t *ent)
{
unsigned mask, compare;
char *s;
ipfilter_t *ip;
int start, argc;
start = ent ? 0 : 1;
argc = gi.argc() - start;
if (argc < 2) {
gi.cprintf(ent, PRINT_HIGH, "Usage: %s <ip-mask>\n", gi.argv(start));
return;
}
s = gi.argv(start + 1);
if (!parse_filter(s, &mask, &compare)) {
gi.cprintf(ent, PRINT_HIGH, "Bad filter address: %s\n", s);
return;
}
FOR_EACH_IPFILTER(ip) {
if (ip->mask == mask && ip->compare == compare) {
if (ent && !ip->duration) {
gi.cprintf(ent, PRINT_HIGH, "You may not remove permanent bans.\n");
return;
}
remove_filter(ip);
gi.cprintf(ent, PRINT_HIGH, "Removed.\n");
return;
}
}
gi.cprintf(ent, PRINT_HIGH, "Didn't find %s.\n", s);
}
/*-------------------------------------------------------------------------
* Function: h5repack_addfilter
*
* Purpose: add a compression -f option to table
* Example: -f dset:GZIP=6
*
* Return: 0, ok, -1, fail
*
*-------------------------------------------------------------------------
*/
int h5repack_addfilter(const char* str, pack_opt_t *options) {
obj_list_t *obj_list = NULL; /* one object list for the -f and -l option entry */
filter_info_t filter; /* filter info for the current -f option entry */
int n_objs; /* number of objects in the current -f or -l option entry */
int is_glb; /* is the filter global */
/* parse the -f option */
if (NULL == (obj_list = parse_filter(str, &n_objs, &filter, options, &is_glb)))
return -1;
/* if it applies to all objects */
if (is_glb) {
int n;
n = options->n_filter_g++; /* increase # of global filters */
if (options->n_filter_g > H5_REPACK_MAX_NFILTERS) {
error_msg("maximum number of filters exceeded for <%s>\n", str);
HDfree(obj_list);
return -1;
}
options->filter_g[n] = filter;
}
else
options_add_filter(obj_list, n_objs, filter, options->op_tbl);
HDfree(obj_list);
return 0;
}
static int usb_host_auto_del(const char *spec)
{
struct USBAutoFilter *pf = usb_auto_filter;
struct USBAutoFilter **prev = &usb_auto_filter;
struct USBAutoFilter filter;
if (parse_filter(spec, &filter) < 0)
return -1;
while (pf) {
if (match_filter(pf, &filter)) {
dprintf("husb: removed auto filter: bus_num %d addr %d vid %d pid %d\n",
pf->bus_num, pf->addr, pf->vendor_id, pf->product_id);
*prev = pf->next;
if (!usb_auto_filter) {
/* No more filters. Stop scanning. */
qemu_del_timer(usb_auto_timer);
qemu_free_timer(usb_auto_timer);
}
return 0;
}
prev = &pf->next;
pf = pf->next;
}
return -1;
}
static void parse_ops(int argc, char **argv, int i)
{
enum { STATE_INIT, STATE_GOT_FILTER, STATE_GOT_OP } state = STATE_INIT;
struct pci_filter filter;
struct pci_dev **selected_devices = NULL;
while (i < argc)
{
char *c = argv[i++];
if (*c == '-')
{
if (state != STATE_GOT_FILTER)
pci_filter_init(pacc, &filter);
i = parse_filter(argc, argv, i-1, &filter);
state = STATE_GOT_FILTER;
}
else
{
if (state == STATE_INIT)
parse_err("Filter specification expected");
if (state == STATE_GOT_FILTER)
selected_devices = select_devices(&filter);
if (!selected_devices[0] && !force)
fprintf(stderr, "setpci: Warning: No devices selected for \"%s\".\n", c);
parse_op(c, selected_devices);
state = STATE_GOT_OP;
}
}
if (state == STATE_INIT)
parse_err("No operation specified");
}
int main(int argc, char **argv)
{
tdb* t = tdb_init();
assert(tdb_open(t, argv[1]) == 0);
parse_filter(t, argv[2], 1);
return 0;
}
/*
=================
G_AddIP_f
=================
*/
void G_AddIP_f(edict_t *ent)
{
unsigned mask, compare;
unsigned duration;
ipaction_t action;
int start, argc;
char *s;
start = ent ? 0 : 1;
argc = gi.argc() - start;
if (argc < 2) {
gi.cprintf(ent, PRINT_HIGH, "Usage: %s <ip-mask> [duration] [action]\n", gi.argv(start));
return;
}
if (numipfilters == MAX_IPFILTERS) {
gi.cprintf(ent, PRINT_HIGH, "IP filter list is full\n");
return;
}
s = gi.argv(start + 1);
if (!parse_filter(s, &mask, &compare)) {
gi.cprintf(ent, PRINT_HIGH, "Bad filter address: %s\n", s);
return;
}
duration = ent ? DEF_DURATION : 0;
action = IPA_BAN;
if (argc > 2) {
s = gi.argv(start + 2);
duration = parse_duration(s);
if (ent) {
if (!duration) {
gi.cprintf(ent, PRINT_HIGH, "You may not add permanent bans.\n");
return;
}
if (duration > MAX_DURATION) {
duration = MAX_DURATION;
}
}
if (argc > 3) {
s = gi.argv(start + 3);
action = parse_action(s);
if (action == IPA_NONE) {
gi.cprintf(ent, PRINT_HIGH, "Bad action specifier: %s\n", s);
return;
}
}
}
add_filter(action, mask, compare, duration, ent);
}
void G_BanEdict(edict_t *victim, edict_t *initiator)
{
unsigned mask, compare;
if (numipfilters == MAX_IPFILTERS) {
return;
}
if (!parse_filter(victim->client->pers.ip, &mask, &compare)) {
return;
}
add_filter(IPA_BAN, mask, compare, DEF_DURATION, initiator);
}
static struct filter *
recursive_parse_chain(char *expr, int operators)
{
struct filter *filt = malloc(sizeof(*filt));
if (filt == NULL) {
fprintf(stderr, "(Part of) filter will be ignored: '%s': %s.\n",
expr, strerror(errno));
return NULL;
}
filter_init(filt);
if (parse_filter(filt, expr, operators) < 0) {
fprintf(stderr, "Filter '%s' will be ignored.\n", expr);
free(filt);
filt = NULL;
}
return filt;
}
/*
* makes array of pipeline parameters
* if any found, return TRUE
* else return FALSE
*/
bool get_pipeline_params(){
int i, N;
char **p = G.conv;
Filter *f;
for(N = 0; *p; ++N, ++p);
farray_size = N;
if(N == 0) return FALSE;
farray = MALLOC(Filter*, farray_size);
p = G.conv;
for(i = 0; i < N; ++i, ++p){
DBG("filter: %s", *p);
if(!(f = parse_filter(*p))){
/// "Неправильно заданы параметры конвейера"
ERRX(_("Wrong pipeline parameters!"));
}
farray[i] = f;
}
return TRUE;
}
USBDevice *usb_host_device_open(USBBus *bus, const char *devname)
{
struct USBAutoFilter filter;
USBDevice *dev;
char *p;
dev = usb_create(bus, "usb-host");
if (strstr(devname, "auto:")) {
if (parse_filter(devname, &filter) < 0) {
goto fail;
}
} else {
p = strchr(devname, '.');
if (p) {
filter.bus_num = strtoul(devname, NULL, 0);
filter.addr = strtoul(p + 1, NULL, 0);
filter.vendor_id = 0;
filter.product_id = 0;
} else {
p = strchr(devname, ':');
if (p) {
filter.bus_num = 0;
filter.addr = 0;
filter.vendor_id = strtoul(devname, NULL, 16);
filter.product_id = strtoul(p + 1, NULL, 16);
} else {
goto fail;
}
}
}
qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
return dev;
fail:
object_unparent(OBJECT(dev));
return NULL;
}
static void
test_odp_main(int argc, char *argv[])
{
int exit_code = 0;
set_program_name(argv[0]);
if (argc == 2 &&!strcmp(argv[1], "parse-keys")) {
exit_code =parse_keys(false);
} else if (argc == 2 &&!strcmp(argv[1], "parse-wc-keys")) {
exit_code =parse_keys(true);
} else if (argc == 2 && !strcmp(argv[1], "parse-actions")) {
exit_code = parse_actions();
} else if (argc == 3 && !strcmp(argv[1], "parse-filter")) {
exit_code =parse_filter(argv[2]);
} else {
ovs_fatal(0, "usage: %s parse-keys | parse-wc-keys | parse-actions", argv[0]);
}
exit(exit_code);
}
static int usb_host_auto_add(const char *spec)
{
struct USBAutoFilter filter, *f;
if (parse_filter(spec, &filter) < 0)
return -1;
f = qemu_mallocz(sizeof(*f));
if (!f) {
fprintf(stderr, "husb: failed to allocate auto filter\n");
return -1;
}
*f = filter;
if (!usb_auto_filter) {
/*
* First entry. Init and start the monitor.
* Right now we're using timer to check for new devices.
* If this turns out to be too expensive we can move that into a
* separate thread.
*/
usb_auto_timer = qemu_new_timer(rt_clock, usb_host_auto_timer, NULL);
if (!usb_auto_timer) {
fprintf(stderr, "husb: failed to allocate auto scan timer\n");
qemu_free(f);
return -1;
}
/* Check for new devices every two seconds */
qemu_mod_timer(usb_auto_timer, qemu_get_clock(rt_clock) + 2000);
}
dprintf("husb: added auto filter: bus_num %d addr %d vid %d pid %d\n",
f->bus_num, f->addr, f->vendor_id, f->product_id);
f->next = usb_auto_filter;
usb_auto_filter = f;
return 0;
}
static struct cconf* parse(void *buf, size_t size) {
struct cconf *c = calloc(1, sizeof(struct cconf));
int i;
/* move! */
c->map.buf = buf;
c->map.size = size;
buf = read_entry_nr(buf + sizeof(struct cconf_header), &c->nr);
c->target = calloc(sizeof(struct target), c->nr);
for(i=0; i < c->nr; i++) {
struct target *target = c->target + i;
buf += parse_target(buf, target);
buf += parse_filter(buf, target);
}
return c;
}
struct tdb_event_filter *apply_filter(tdb *db, struct tdbcli_options *opt)
{
struct tdb_event_filter *f = NULL;
tdb_opt_value value;
if (opt->filter_arg)
f = parse_filter(db, opt->filter_arg, opt->verbose);
if (opt->uuids){
/* all and none are never freed, not a biggie */
if (f)
apply_uuids(db, f, opt);
else
apply_uuids(db, tdb_event_filter_new_match_all(), opt);
value.ptr = tdb_event_filter_new_match_none();
}else
value.ptr = f;
if (tdb_set_opt(db, TDB_OPT_EVENT_FILTER, value))
DIE("Could not set event filter");
return f;
}
error_code ContentDirectory::Browse(const client_info_ptr& client,
const http::http_request& /*http_request*/,
/* IN */ const std::string& ObjectID,
/* IN */ A_ARG_TYPE_BrowseFlag BrowseFlag,
/* IN */ const std::string& Filter,
/* IN */ ui4 StartingIndex,
/* IN */ ui4 RequestedCount,
/* IN */ const std::string& /*SortCriteria*/,
/* OUT */ std::string& Result,
/* OUT */ ui4& NumberReturned,
/* OUT */ ui4& TotalMatches,
/* OUT */ ui4& UpdateID)
{
if (BrowseFlag == A_ARG_TYPE_BrowseFlag_UNKNOWN)
return error::invalid_action;
std::ostringstream value;
NumberReturned = 0;
TotalMatches = 0;
UpdateID = m_device->system_update_id();
{
value << R"(<DIDL-Lite xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/">)" "\n";
auto item = m_device->get_item(ObjectID);
if (item)
log::debug() << type_info<A_ARG_TYPE_BrowseFlag>::to_string(BrowseFlag) << " [" << ObjectID << "] \"" << item->get_title() << "\"";
else
log::warning() << type_info<A_ARG_TYPE_BrowseFlag>::to_string(BrowseFlag) << " [" << ObjectID << "] failed";
if (item)
{
auto client_ptr = std::static_pointer_cast<client_interface>(client);
auto filter = parse_filter(Filter);
if (BrowseFlag == VALUE_BrowseDirectChildren)
{
auto children = item->list(StartingIndex, RequestedCount);
for (auto && child : children)
{
log::debug() << " [" << child->get_objectId_attr() << "] \"" << child->get_title() << "\"";
child->output(value, filter, client_ptr, m_device->config());
}
NumberReturned = children.size();
TotalMatches = item->predict_count(StartingIndex + NumberReturned);
}
else
{
item->check_updates();
item->output(value, filter, client_ptr, m_device->config());
NumberReturned = 1;
TotalMatches = 1;
}
// could change during the item->list
UpdateID = item->update_id();
}
value << "</DIDL-Lite>";
}
Result = std::move(value.str());
return error::no_error;
}
static errno_t
ad_parse_access_filter(TALLOC_CTX *mem_ctx,
struct sss_domain_info *dom,
const char *filter_list,
char **_filter)
{
char **filters;
int nfilters;
errno_t ret;
char *best_match;
int best_flags;
char *filter;
char *spec;
int flags;
TALLOC_CTX *tmp_ctx;
int i = 0;
if (_filter == NULL) return EINVAL;
tmp_ctx = talloc_new(mem_ctx);
if (tmp_ctx == NULL) {
ret = ENOMEM;
goto done;
}
if (filter_list == NULL) {
*_filter = NULL;
ret = EOK;
goto done;
}
ret = split_on_separator(tmp_ctx, filter_list, '?', true, true,
&filters, &nfilters);
if (ret != EOK) {
DEBUG(SSSDBG_CRIT_FAILURE,
"Cannot parse the list of ad_access_filters\n");
goto done;
}
best_match = NULL;
best_flags = 0;
for (i=0; i < nfilters; i++) {
ret = parse_filter(tmp_ctx, filters[i], &filter, &spec, &flags);
if (ret != EOK) {
/* Skip the faulty filter. At worst, the user won't be
* allowed access */
DEBUG(SSSDBG_MINOR_FAILURE, "Access filter [%s] could not be "
"parsed, skipping\n", filters[i]);
continue;
}
if (flags & AD_FILTER_DOMAIN && strcasecmp(spec, dom->name) != 0) {
/* If the filter specifies a domain, it must match the
* domain the user comes from
*/
continue;
}
if (flags & AD_FILTER_FOREST && strcasecmp(spec, dom->forest) != 0) {
/* If the filter specifies a forest, it must match the
* forest the user comes from
*/
continue;
}
if (flags > best_flags) {
best_flags = flags;
best_match = filter;
}
}
ret = EOK;
/* Make sure the result is enclosed in brackets */
*_filter = sdap_get_access_filter(mem_ctx, best_match);
done:
talloc_free(tmp_ctx);
return ret;
}
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
AVFilterInOut *open_inputs,
AVFilterInOut *open_outputs, AVClass *log_ctx)
{
int index = 0, ret;
char chr = 0;
AVFilterInOut *curr_inputs = NULL;
do {
AVFilterContext *filter;
const char *filterchain = filters;
filters += strspn(filters, WHITESPACES);
if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, log_ctx)) < 0)
goto fail;
if ((ret = parse_filter(&filter, &filters, graph, index, log_ctx)) < 0)
goto fail;
if (filter->input_count == 1 && !curr_inputs && !index) {
/* First input can be omitted if it is "[in]" */
const char *tmp = "[in]";
if ((ret = parse_inputs(&tmp, &curr_inputs, &open_outputs, log_ctx)) < 0)
goto fail;
}
if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, log_ctx)) < 0)
goto fail;
if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,
log_ctx)) < 0)
goto fail;
filters += strspn(filters, WHITESPACES);
chr = *filters++;
if (chr == ';' && curr_inputs) {
av_log(log_ctx, AV_LOG_ERROR,
"Invalid filterchain containing an unlabelled output pad: \"%s\"\n",
filterchain);
ret = AVERROR(EINVAL);
goto fail;
}
index++;
} while (chr == ',' || chr == ';');
if (chr) {
av_log(log_ctx, AV_LOG_ERROR,
"Unable to parse graph description substring: \"%s\"\n",
filters - 1);
ret = AVERROR(EINVAL);
goto fail;
}
if (open_inputs && !strcmp(open_inputs->name, "out") && curr_inputs) {
/* Last output can be omitted if it is "[out]" */
const char *tmp = "[out]";
if ((ret = parse_outputs(&tmp, &curr_inputs, &open_inputs, &open_outputs,
log_ctx)) < 0)
goto fail;
}
return 0;
fail:
for (; graph->filter_count > 0; graph->filter_count--)
avfilter_free(graph->filters[graph->filter_count - 1]);
av_freep(&graph->filters);
free_inout(open_inputs);
free_inout(open_outputs);
free_inout(curr_inputs);
return ret;
}
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
AVFilterInOut *open_inputs,
AVFilterInOut *open_outputs, void *log_ctx)
{
int ret;
AVFilterInOut *cur, *match, *inputs = NULL, *outputs = NULL;
if ((ret = avfilter_graph_parse2(graph, filters, &inputs, &outputs)) < 0)
goto fail;
/* First input can be omitted if it is "[in]" */
if (inputs && !inputs->name)
inputs->name = av_strdup("in");
for (cur = inputs; cur; cur = cur->next) {
if (!cur->name) {
av_log(log_ctx, AV_LOG_ERROR,
"Not enough inputs specified for the \"%s\" filter.\n",
cur->filter_ctx->filter->name);
ret = AVERROR(EINVAL);
goto fail;
}
if (!(match = extract_inout(cur->name, &open_outputs)))
continue;
ret = avfilter_link(match->filter_ctx, match->pad_idx,
cur->filter_ctx, cur->pad_idx);
avfilter_inout_free(&match);
if (ret < 0)
goto fail;
}
/* Last output can be omitted if it is "[out]" */
if (outputs && !outputs->name)
outputs->name = av_strdup("out");
for (cur = outputs; cur; cur = cur->next) {
if (!cur->name) {
av_log(log_ctx, AV_LOG_ERROR,
"Invalid filterchain containing an unlabelled output pad: \"%s\"\n",
filters);
ret = AVERROR(EINVAL);
goto fail;
}
if (!(match = extract_inout(cur->name, &open_inputs)))
continue;
ret = avfilter_link(cur->filter_ctx, cur->pad_idx,
match->filter_ctx, match->pad_idx);
avfilter_inout_free(&match);
if (ret < 0)
goto fail;
}
fail:
if (ret < 0) {
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
av_freep(&graph->filters);
}
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
avfilter_inout_free(&open_inputs);
avfilter_inout_free(&open_outputs);
return ret;
#else
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
AVFilterInOut **inputs, AVFilterInOut **outputs,
void *log_ctx)
{
return avfilter_graph_parse_ptr(graph, filters, inputs, outputs, log_ctx);
#endif
}
int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters,
AVFilterInOut **open_inputs_ptr, AVFilterInOut **open_outputs_ptr,
void *log_ctx)
{
int index = 0, ret = 0;
char chr = 0;
AVFilterInOut *curr_inputs = NULL;
AVFilterInOut *open_inputs = open_inputs_ptr ? *open_inputs_ptr : NULL;
AVFilterInOut *open_outputs = open_outputs_ptr ? *open_outputs_ptr : NULL;
if ((ret = parse_sws_flags(&filters, graph)) < 0)
goto end;
do {
AVFilterContext *filter;
const char *filterchain = filters;
filters += strspn(filters, WHITESPACES);
if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, log_ctx)) < 0)
goto end;
if ((ret = parse_filter(&filter, &filters, graph, index, log_ctx)) < 0)
goto end;
if (filter->nb_inputs == 1 && !curr_inputs && !index) {
/* First input pad, assume it is "[in]" if not specified */
const char *tmp = "[in]";
if ((ret = parse_inputs(&tmp, &curr_inputs, &open_outputs, log_ctx)) < 0)
goto end;
}
if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, log_ctx)) < 0)
goto end;
if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,
log_ctx)) < 0)
goto end;
filters += strspn(filters, WHITESPACES);
chr = *filters++;
if (chr == ';' && curr_inputs) {
av_log(log_ctx, AV_LOG_ERROR,
"Invalid filterchain containing an unlabelled output pad: \"%s\"\n",
filterchain);
ret = AVERROR(EINVAL);
goto end;
}
index++;
} while (chr == ',' || chr == ';');
if (chr) {
av_log(log_ctx, AV_LOG_ERROR,
"Unable to parse graph description substring: \"%s\"\n",
filters - 1);
ret = AVERROR(EINVAL);
goto end;
}
if (curr_inputs) {
/* Last output pad, assume it is "[out]" if not specified */
const char *tmp = "[out]";
if ((ret = parse_outputs(&tmp, &curr_inputs, &open_inputs, &open_outputs,
log_ctx)) < 0)
goto end;
}
end:
/* clear open_in/outputs only if not passed as parameters */
if (open_inputs_ptr) *open_inputs_ptr = open_inputs;
else avfilter_inout_free(&open_inputs);
if (open_outputs_ptr) *open_outputs_ptr = open_outputs;
else avfilter_inout_free(&open_outputs);
avfilter_inout_free(&curr_inputs);
if (ret < 0) {
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
av_freep(&graph->filters);
}
return ret;
}
int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
AVFilterInOut **inputs,
AVFilterInOut **outputs)
{
int index = 0, ret = 0;
char chr = 0;
AVFilterInOut *curr_inputs = NULL, *open_inputs = NULL, *open_outputs = NULL;
filters += strspn(filters, WHITESPACES);
if ((ret = parse_sws_flags(&filters, graph)) < 0)
goto fail;
do {
AVFilterContext *filter;
filters += strspn(filters, WHITESPACES);
if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, graph)) < 0)
goto end;
if ((ret = parse_filter(&filter, &filters, graph, index, graph)) < 0)
goto end;
if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, graph)) < 0)
goto end;
if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,
graph)) < 0)
goto end;
filters += strspn(filters, WHITESPACES);
chr = *filters++;
if (chr == ';' && curr_inputs)
append_inout(&open_outputs, &curr_inputs);
index++;
} while (chr == ',' || chr == ';');
if (chr) {
av_log(graph, AV_LOG_ERROR,
"Unable to parse graph description substring: \"%s\"\n",
filters - 1);
ret = AVERROR(EINVAL);
goto end;
}
append_inout(&open_outputs, &curr_inputs);
*inputs = open_inputs;
*outputs = open_outputs;
return 0;
fail:end:
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
av_freep(&graph->filters);
avfilter_inout_free(&open_inputs);
avfilter_inout_free(&open_outputs);
avfilter_inout_free(&curr_inputs);
*inputs = NULL;
*outputs = NULL;
return ret;
}
bool DeckBuilder::OnEvent(const irr::SEvent& event) {
switch(event.EventType) {
case irr::EET_GUI_EVENT: {
s32 id = event.GUIEvent.Caller->getID();
if(mainGame->wCategories->isVisible() && id != BUTTON_CATEGORY_OK)
break;
if(mainGame->wQuery->isVisible() && id != BUTTON_YES && id != BUTTON_NO)
break;
switch(event.GUIEvent.EventType) {
case irr::gui::EGET_BUTTON_CLICKED: {
switch(id) {
case BUTTON_CLEAR_DECK: {
mainGame->gMutex.Lock();
mainGame->SetStaticText(mainGame->stQMessage, 310, mainGame->textFont, (wchar_t*)dataManager.GetSysString(1339));
mainGame->PopupElement(mainGame->wQuery);
mainGame->gMutex.Unlock();
is_clearing = true;
break;
}
case BUTTON_SORT_DECK: {
std::sort(deckManager.current_deck.main.begin(), deckManager.current_deck.main.end(), ClientCard::deck_sort_lv);
std::sort(deckManager.current_deck.extra.begin(), deckManager.current_deck.extra.end(), ClientCard::deck_sort_lv);
std::sort(deckManager.current_deck.side.begin(), deckManager.current_deck.side.end(), ClientCard::deck_sort_lv);
break;
}
case BUTTON_SHUFFLE_DECK: {
std::random_shuffle(deckManager.current_deck.main.begin(), deckManager.current_deck.main.end());
break;
}
case BUTTON_SAVE_DECK: {
if(deckManager.SaveDeck(deckManager.current_deck, mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()))) {
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
case BUTTON_SAVE_DECK_AS: {
const wchar_t* dname = mainGame->ebDeckname->getText();
if(*dname == 0)
break;
int sel = -1;
for(size_t i = 0; i < mainGame->cbDBDecks->getItemCount(); ++i) {
if(!wcscmp(dname, mainGame->cbDBDecks->getItem(i))) {
sel = i;
break;
}
}
if(sel >= 0)
mainGame->cbDBDecks->setSelected(sel);
else {
mainGame->cbDBDecks->addItem(dname);
mainGame->cbDBDecks->setSelected(mainGame->cbDBDecks->getItemCount() - 1);
}
if(deckManager.SaveDeck(deckManager.current_deck, dname)) {
mainGame->stACMessage->setText(dataManager.GetSysString(1335));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
break;
}
case BUTTON_DELETE_DECK: {
int sel = mainGame->cbDBDecks->getSelected();
if(sel == -1)
break;
mainGame->gMutex.Lock();
wchar_t textBuffer[256];
myswprintf(textBuffer, L"%ls\n%ls", mainGame->cbDBDecks->getItem(sel), dataManager.GetSysString(1337));
mainGame->SetStaticText(mainGame->stQMessage, 310, mainGame->textFont, (wchar_t*)textBuffer);
mainGame->PopupElement(mainGame->wQuery);
mainGame->gMutex.Unlock();
is_deleting = true;
break;
}
case BUTTON_LEAVE_GAME: {
mainGame->is_building = false;
mainGame->wDeckEdit->setVisible(false);
mainGame->wCategories->setVisible(false);
mainGame->wFilter->setVisible(false);
mainGame->wSort->setVisible(false);
mainGame->wCardImg->setVisible(false);
mainGame->wInfos->setVisible(false);
mainGame->btnLeaveGame->setVisible(false);
mainGame->PopupElement(mainGame->wMainMenu);
mainGame->device->setEventReceiver(&mainGame->menuHandler);
mainGame->wACMessage->setVisible(false);
imageManager.ClearTexture();
mainGame->scrFilter->setVisible(false);
if(mainGame->cbDBDecks->getSelected() != -1) {
BufferIO::CopyWStr(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()), mainGame->gameConf.lastdeck, 64);
}
if(exit_on_return)
mainGame->device->closeDevice();
break;
}
case BUTTON_EFFECT_FILTER: {
mainGame->PopupElement(mainGame->wCategories);
break;
}
case BUTTON_START_FILTER: {
filter_type = mainGame->cbCardType->getSelected();
filter_type2 = mainGame->cbCardType2->getItemData(mainGame->cbCardType2->getSelected());
filter_lm = mainGame->cbLimit->getSelected();
if(filter_type == 1) {
filter_attrib = mainGame->cbAttribute->getItemData(mainGame->cbAttribute->getSelected());
filter_race = mainGame->cbRace->getItemData(mainGame->cbRace->getSelected());
filter_atk = parse_filter(mainGame->ebAttack->getText(), &filter_atktype);
filter_def = parse_filter(mainGame->ebDefense->getText(), &filter_deftype);
filter_lv = parse_filter(mainGame->ebStar->getText(), &filter_lvtype);
filter_scl = parse_filter(mainGame->ebScale->getText(), &filter_scltype);
}
FilterCards();
if(!mainGame->gameConf.separate_clear_button)
ClearFilter();
break;
}
case BUTTON_CLEAR_FILTER: {
ClearSearch();
break;
}
case BUTTON_CATEGORY_OK: {
filter_effect = 0;
long long filter = 0x1;
for(int i = 0; i < 32; ++i, filter <<= 1)
if(mainGame->chkCategory[i]->isChecked())
filter_effect |= filter;
mainGame->HideElement(mainGame->wCategories);
break;
}
case BUTTON_SIDE_OK: {
if(deckManager.current_deck.main.size() != pre_mainc || deckManager.current_deck.extra.size() != pre_extrac
|| deckManager.current_deck.side.size() != pre_sidec) {
mainGame->env->addMessageBox(L"", dataManager.GetSysString(1410));
break;
}
char deckbuf[1024];
char* pdeck = deckbuf;
BufferIO::WriteInt32(pdeck, deckManager.current_deck.main.size() + deckManager.current_deck.extra.size());
BufferIO::WriteInt32(pdeck, deckManager.current_deck.side.size());
for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.main[i]->first);
for(size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.extra[i]->first);
for(size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
BufferIO::WriteInt32(pdeck, deckManager.current_deck.side[i]->first);
DuelClient::SendBufferToServer(CTOS_UPDATE_DECK, deckbuf, pdeck - deckbuf);
break;
}
case BUTTON_YES: {
mainGame->HideElement(mainGame->wQuery);
if(!mainGame->is_building || mainGame->is_siding)
break;
if(is_clearing) {
deckManager.current_deck.main.clear();
deckManager.current_deck.extra.clear();
deckManager.current_deck.side.clear();
} else if(is_deleting) {
int sel = mainGame->cbDBDecks->getSelected();
if (deckManager.DeleteDeck(deckManager.current_deck, mainGame->cbDBDecks->getItem(sel))) {
mainGame->cbDBDecks->removeItem(sel);
int count = mainGame->cbDBDecks->getItemCount();
if (sel >= count)
sel = count - 1;
mainGame->cbDBDecks->setSelected(sel);
if (sel != -1)
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(sel));
mainGame->stACMessage->setText(dataManager.GetSysString(1338));
mainGame->PopupElement(mainGame->wACMessage, 20);
}
}
is_clearing = false;
is_deleting = false;
break;
}
case BUTTON_NO: {
mainGame->HideElement(mainGame->wQuery);
is_deleting = false;
is_clearing = false;
break;
}
}
break;
}
case irr::gui::EGET_SCROLL_BAR_CHANGED: {
switch(id) {
case SCROLL_CARDTEXT: {
u32 pos = mainGame->scrCardText->getPos();
mainGame->SetStaticText(mainGame->stText, mainGame->stText->getRelativePosition().getWidth()-25, mainGame->textFont, mainGame->showingtext, pos);
break;
}
break;
}
}
case irr::gui::EGET_EDITBOX_ENTER: {
switch(id) {
case EDITBOX_KEYWORD: {
irr::SEvent me;
me.EventType = irr::EET_GUI_EVENT;
me.GUIEvent.EventType = irr::gui::EGET_BUTTON_CLICKED;
me.GUIEvent.Caller = mainGame->btnStartFilter;
me.GUIEvent.Element = mainGame->btnStartFilter;
mainGame->device->postEventFromUser(me);
break;
}
}
break;
}
case irr::gui::EGET_COMBO_BOX_CHANGED: {
switch(id) {
case COMBOBOX_DBLFLIST: {
filterList = deckManager._lfList[mainGame->cbDBLFList->getSelected()].content;
break;
}
case COMBOBOX_DBDECKS: {
deckManager.LoadDeck(mainGame->cbDBDecks->getItem(mainGame->cbDBDecks->getSelected()));
break;
}
case COMBOBOX_MAINTYPE: {
mainGame->cbCardType2->setSelected(0);
mainGame->cbAttribute->setSelected(0);
mainGame->cbRace->setSelected(0);
mainGame->ebAttack->setText(L"");
mainGame->ebDefense->setText(L"");
mainGame->ebStar->setText(L"");
mainGame->ebScale->setText(L"");
switch(mainGame->cbCardType->getSelected()) {
case 0: {
mainGame->cbCardType2->setEnabled(false);
mainGame->cbCardType2->setSelected(0);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
break;
}
case 1: {
wchar_t normaltuner[32];
wchar_t normalpen[32];
wchar_t syntuner[32];
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(true);
mainGame->cbAttribute->setEnabled(true);
mainGame->ebAttack->setEnabled(true);
mainGame->ebDefense->setEnabled(true);
mainGame->ebStar->setEnabled(true);
mainGame->ebScale->setEnabled(true);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_MONSTER + TYPE_NORMAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1055), TYPE_MONSTER + TYPE_EFFECT);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1056), TYPE_MONSTER + TYPE_FUSION);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1057), TYPE_MONSTER + TYPE_RITUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1063), TYPE_MONSTER + TYPE_SYNCHRO);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1073), TYPE_MONSTER + TYPE_XYZ);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1074), TYPE_MONSTER + TYPE_PENDULUM);
myswprintf(normaltuner, L"%ls|%ls", dataManager.GetSysString(1054), dataManager.GetSysString(1062));
mainGame->cbCardType2->addItem(normaltuner, TYPE_MONSTER + TYPE_NORMAL + TYPE_TUNER);
myswprintf(normalpen, L"%ls|%ls", dataManager.GetSysString(1054), dataManager.GetSysString(1074));
mainGame->cbCardType2->addItem(normalpen, TYPE_MONSTER + TYPE_NORMAL + TYPE_PENDULUM);
myswprintf(syntuner, L"%ls|%ls", dataManager.GetSysString(1063), dataManager.GetSysString(1062));
mainGame->cbCardType2->addItem(syntuner, TYPE_MONSTER + TYPE_SYNCHRO + TYPE_TUNER);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1062), TYPE_MONSTER + TYPE_TUNER);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1061), TYPE_MONSTER + TYPE_DUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1060), TYPE_MONSTER + TYPE_UNION);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1059), TYPE_MONSTER + TYPE_SPIRIT);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1071), TYPE_MONSTER + TYPE_FLIP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1072), TYPE_MONSTER + TYPE_TOON);
break;
}
case 2: {
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_SPELL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1066), TYPE_SPELL + TYPE_QUICKPLAY);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1067), TYPE_SPELL + TYPE_CONTINUOUS);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1057), TYPE_SPELL + TYPE_RITUAL);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1068), TYPE_SPELL + TYPE_EQUIP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1069), TYPE_SPELL + TYPE_FIELD);
break;
}
case 3: {
mainGame->cbCardType2->setEnabled(true);
mainGame->cbRace->setEnabled(false);
mainGame->cbAttribute->setEnabled(false);
mainGame->ebAttack->setEnabled(false);
mainGame->ebDefense->setEnabled(false);
mainGame->ebStar->setEnabled(false);
mainGame->ebScale->setEnabled(false);
mainGame->cbCardType2->clear();
mainGame->cbCardType2->addItem(dataManager.GetSysString(1080), 0);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1054), TYPE_TRAP);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1067), TYPE_TRAP + TYPE_CONTINUOUS);
mainGame->cbCardType2->addItem(dataManager.GetSysString(1070), TYPE_TRAP + TYPE_COUNTER);
break;
}
}
break;
}
case COMBOBOX_SORTTYPE: {
SortList();
mainGame->env->setFocus(0);
break;
}
}
}
default:
break;
}
break;
}
case irr::EET_MOUSE_INPUT_EVENT: {
switch(event.MouseInput.Event) {
case irr::EMIE_LMOUSE_PRESSED_DOWN: {
irr::core::position2di mouse_pos(event.MouseInput.X, event.MouseInput.Y);
irr::gui::IGUIElement* root = mainGame->env->getRootGUIElement();
if(root->getElementFromPoint(mouse_pos) != root)
break;
if(mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
click_pos = hovered_pos;
dragx = event.MouseInput.X;
dragy = event.MouseInput.Y;
draging_pointer = dataManager.GetCodePointer(hovered_code);
if(draging_pointer == dataManager._datas.end())
break;
unsigned int limitcode = draging_pointer->second.alias ? draging_pointer->second.alias : draging_pointer->first;
if(hovered_pos == 4) {
int limit = 3;
if(filterList->count(limitcode))
limit = (*filterList)[limitcode];
for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
if(deckManager.current_deck.main[i]->first == limitcode
|| deckManager.current_deck.main[i]->second.alias == limitcode)
limit--;
for(size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
if(deckManager.current_deck.extra[i]->first == limitcode
|| deckManager.current_deck.extra[i]->second.alias == limitcode)
limit--;
for(size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
if(deckManager.current_deck.side[i]->first == limitcode
|| deckManager.current_deck.side[i]->second.alias == limitcode)
limit--;
if(limit <= 0)
break;
}
if(hovered_pos == 1)
deckManager.current_deck.main.erase(deckManager.current_deck.main.begin() + hovered_seq);
else if(hovered_pos == 2)
deckManager.current_deck.extra.erase(deckManager.current_deck.extra.begin() + hovered_seq);
else if(hovered_pos == 3)
deckManager.current_deck.side.erase(deckManager.current_deck.side.begin() + hovered_seq);
is_draging = true;
break;
}
case irr::EMIE_LMOUSE_LEFT_UP: {
if(!is_draging)
break;
if(!mainGame->is_siding) {
if((hovered_pos == 1 && (draging_pointer->second.type & 0x802040)) || (hovered_pos == 2 && !(draging_pointer->second.type & 0x802040)))
hovered_pos = 0;
if((hovered_pos == 1 || (hovered_pos == 0 && click_pos == 1)) && deckManager.current_deck.main.size() < 60) {
if(hovered_seq == -1)
deckManager.current_deck.main.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.main.size() && hovered_pos)
deckManager.current_deck.main.insert(deckManager.current_deck.main.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.main.push_back(draging_pointer);
is_draging = false;
} else if((hovered_pos == 2 || (hovered_pos == 0 && click_pos == 2)) && deckManager.current_deck.extra.size() < 15) {
if(hovered_seq == -1)
deckManager.current_deck.extra.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.extra.size() && hovered_pos)
deckManager.current_deck.extra.insert(deckManager.current_deck.extra.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.extra.push_back(draging_pointer);
is_draging = false;
} else if((hovered_pos == 3 || (hovered_pos == 0 && click_pos == 3)) && deckManager.current_deck.side.size() < 15) {
if(hovered_seq == -1)
deckManager.current_deck.side.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.side.size() && hovered_pos)
deckManager.current_deck.side.insert(deckManager.current_deck.side.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
} else if (hovered_pos == 4)
is_draging = false;
} else {
if((hovered_pos == 1 && (draging_pointer->second.type & 0x802040)) || (hovered_pos == 2 && !(draging_pointer->second.type & 0x802040)) || hovered_pos == 4)
hovered_pos = 0;
if((hovered_pos == 1 || (hovered_pos == 0 && click_pos == 1)) && deckManager.current_deck.main.size() < 65) {
if(hovered_seq == -1)
deckManager.current_deck.main.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.main.size() && hovered_pos)
deckManager.current_deck.main.insert(deckManager.current_deck.main.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.main.push_back(draging_pointer);
is_draging = false;
} else if((hovered_pos == 2 || (hovered_pos == 0 && click_pos == 2)) && deckManager.current_deck.extra.size() < 20) {
if(hovered_seq == -1)
deckManager.current_deck.extra.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.extra.size() && hovered_pos)
deckManager.current_deck.extra.insert(deckManager.current_deck.extra.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.extra.push_back(draging_pointer);
is_draging = false;
} else if((hovered_pos == 3 || (hovered_pos == 0 && click_pos == 3)) && deckManager.current_deck.side.size() < 20) {
if(hovered_seq == -1)
deckManager.current_deck.side.push_back(draging_pointer);
else if(hovered_seq < (int)deckManager.current_deck.side.size() && hovered_pos)
deckManager.current_deck.side.insert(deckManager.current_deck.side.begin() + hovered_seq, draging_pointer);
else deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
}
}
if(is_draging) {
if(click_pos == 1)
deckManager.current_deck.main.push_back(draging_pointer);
else if(click_pos == 2)
deckManager.current_deck.extra.push_back(draging_pointer);
else if(click_pos == 3)
deckManager.current_deck.side.push_back(draging_pointer);
}
is_draging = false;
break;
}
case irr::EMIE_RMOUSE_LEFT_UP: {
if(mainGame->is_siding) {
if(is_draging)
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
draging_pointer = dataManager.GetCodePointer(hovered_code);
if(draging_pointer == dataManager._datas.end())
break;
if(hovered_pos == 1) {
if(deckManager.current_deck.side.size() < 20) {
deckManager.current_deck.main.erase(deckManager.current_deck.main.begin() + hovered_seq);
deckManager.current_deck.side.push_back(draging_pointer);
}
} else if(hovered_pos == 2) {
if(deckManager.current_deck.side.size() < 20) {
deckManager.current_deck.extra.erase(deckManager.current_deck.extra.begin() + hovered_seq);
deckManager.current_deck.side.push_back(draging_pointer);
}
} else {
if((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 20) {
deckManager.current_deck.side.erase(deckManager.current_deck.side.begin() + hovered_seq);
deckManager.current_deck.extra.push_back(draging_pointer);
}
if(!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 64) {
deckManager.current_deck.side.erase(deckManager.current_deck.side.begin() + hovered_seq);
deckManager.current_deck.main.push_back(draging_pointer);
}
}
break;
}
if(mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if(hovered_pos == 0 || hovered_seq == -1)
break;
if(!is_draging) {
draging_pointer = dataManager.GetCodePointer(hovered_code);
if(draging_pointer == dataManager._datas.end())
break;
}
if(hovered_pos == 1) {
if(!is_draging)
deckManager.current_deck.main.erase(deckManager.current_deck.main.begin() + hovered_seq);
else if(deckManager.current_deck.side.size() < 15) {
deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
}
} else if(hovered_pos == 2) {
if(!is_draging)
deckManager.current_deck.extra.erase(deckManager.current_deck.extra.begin() + hovered_seq);
else if(deckManager.current_deck.side.size() < 15) {
deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
}
} else if(hovered_pos == 3) {
if(!is_draging)
deckManager.current_deck.side.erase(deckManager.current_deck.side.begin() + hovered_seq);
else {
if((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 15) {
deckManager.current_deck.extra.push_back(draging_pointer);
is_draging = false;
} else if(!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 60) {
deckManager.current_deck.main.push_back(draging_pointer);
is_draging = false;
}
}
} else {
if(is_draging) {
if(deckManager.current_deck.side.size() < 15) {
deckManager.current_deck.side.push_back(draging_pointer);
is_draging = false;
}
} else {
unsigned int limitcode = draging_pointer->second.alias ? draging_pointer->second.alias : draging_pointer->first;
int limit = 3;
if(filterList->count(limitcode))
limit = (*filterList)[limitcode];
for(size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
if(deckManager.current_deck.main[i]->first == limitcode
|| deckManager.current_deck.main[i]->second.alias == limitcode)
limit--;
for(size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
if(deckManager.current_deck.extra[i]->first == limitcode
|| deckManager.current_deck.extra[i]->second.alias == limitcode)
limit--;
for(size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
if(deckManager.current_deck.side[i]->first == limitcode
|| deckManager.current_deck.side[i]->second.alias == limitcode)
limit--;
if(limit <= 0)
break;
if((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 15) {
deckManager.current_deck.extra.push_back(draging_pointer);
} else if(!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 60) {
deckManager.current_deck.main.push_back(draging_pointer);
} else if (deckManager.current_deck.side.size() < 15) {
deckManager.current_deck.side.push_back(draging_pointer);
}
}
}
break;
}
case irr::EMIE_MMOUSE_LEFT_UP: {
if (mainGame->is_siding)
break;
if (mainGame->wCategories->isVisible() || mainGame->wQuery->isVisible())
break;
if (hovered_pos == 0 || hovered_seq == -1)
break;
if (is_draging)
break;
draging_pointer = dataManager.GetCodePointer(hovered_code);
unsigned int limitcode = draging_pointer->second.alias ? draging_pointer->second.alias : draging_pointer->first;
int limit = 3;
if (filterList->count(limitcode))
limit = (*filterList)[limitcode];
for (size_t i = 0; i < deckManager.current_deck.main.size(); ++i)
if (deckManager.current_deck.main[i]->first == limitcode
|| deckManager.current_deck.main[i]->second.alias == limitcode)
limit--;
for (size_t i = 0; i < deckManager.current_deck.extra.size(); ++i)
if (deckManager.current_deck.extra[i]->first == limitcode
|| deckManager.current_deck.extra[i]->second.alias == limitcode)
limit--;
for (size_t i = 0; i < deckManager.current_deck.side.size(); ++i)
if (deckManager.current_deck.side[i]->first == limitcode
|| deckManager.current_deck.side[i]->second.alias == limitcode)
limit--;
if (limit <= 0)
break;
if (hovered_pos == 1) {
if (deckManager.current_deck.main.size() < 60)
deckManager.current_deck.main.push_back(draging_pointer);
else if (deckManager.current_deck.side.size() < 15)
deckManager.current_deck.side.push_back(draging_pointer);
} else if (hovered_pos == 2) {
if (deckManager.current_deck.extra.size() < 15)
deckManager.current_deck.extra.push_back(draging_pointer);
else if (deckManager.current_deck.side.size() < 15)
deckManager.current_deck.side.push_back(draging_pointer);
} else if (hovered_pos == 3) {
if (deckManager.current_deck.side.size() < 15)
deckManager.current_deck.side.push_back(draging_pointer);
else {
if ((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 15)
deckManager.current_deck.extra.push_back(draging_pointer);
else if (!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 60)
deckManager.current_deck.main.push_back(draging_pointer);
}
} else {
if ((draging_pointer->second.type & 0x802040) && deckManager.current_deck.extra.size() < 15)
deckManager.current_deck.extra.push_back(draging_pointer);
else if (!(draging_pointer->second.type & 0x802040) && deckManager.current_deck.main.size() < 60)
deckManager.current_deck.main.push_back(draging_pointer);
else if (deckManager.current_deck.side.size() < 15)
deckManager.current_deck.side.push_back(draging_pointer);
}
break;
}
case irr::EMIE_MOUSE_MOVED: {
int x = event.MouseInput.X;
int y = event.MouseInput.Y;
irr::core::position2di mouse_pos(x, y);
irr::gui::IGUIElement* root = mainGame->env->getRootGUIElement();
if(root->getElementFromPoint(mouse_pos) != root)
break;
int pre_code = hovered_code;
if(x >= 314 && x <= 794 && y >= 164 && y <= 435) {
int lx = 10, px, py = (y - 164) / 68;
hovered_pos = 1;
if(deckManager.current_deck.main.size() > 40)
lx = (deckManager.current_deck.main.size() - 41) / 4 + 11;
if(x >= 750)
px = lx - 1;
else px = (x - 314) * (lx - 1) / 436;
if(py*lx + px >= (int)deckManager.current_deck.main.size()) {
hovered_seq = -1;
hovered_code = 0;
} else {
hovered_seq = py * lx + px;
hovered_code = deckManager.current_deck.main[hovered_seq]->first;
}
} else if(x >= 314 && x <= 794 && y >= 466 && y <= 530) {
int lx = deckManager.current_deck.extra.size();
hovered_pos = 2;
if(lx < 10)
lx = 10;
if(x >= 750)
hovered_seq = lx - 1;
else hovered_seq = (x - 314) * (lx - 1) / 436;
if(hovered_seq >= (int)deckManager.current_deck.extra.size()) {
hovered_seq = -1;
hovered_code = 0;
} else {
hovered_code = deckManager.current_deck.extra[hovered_seq]->first;
}
} else if (x >= 314 && x <= 794 && y >= 564 && y <= 628) {
int lx = deckManager.current_deck.side.size();
hovered_pos = 3;
if(lx < 10)
lx = 10;
if(x >= 750)
hovered_seq = lx - 1;
else hovered_seq = (x - 314) * (lx - 1) / 436;
if(hovered_seq >= (int)deckManager.current_deck.side.size()) {
hovered_seq = -1;
hovered_code = 0;
} else {
hovered_code = deckManager.current_deck.side[hovered_seq]->first;
}
} else if(x >= 810 && x <= 995 && y >= 165 && y <= 626) {
hovered_pos = 4;
hovered_seq = (y - 165) / 66;
if(mainGame->scrFilter->getPos() + hovered_seq >= (int)results.size()) {
hovered_seq = -1;
hovered_code = 0;
} else {
hovered_code = results[mainGame->scrFilter->getPos() + hovered_seq]->first;
}
} else {
hovered_pos = 0;
hovered_code = 0;
}
if(is_draging) {
dragx = x;
dragy = y;
}
if(!is_draging && pre_code != hovered_code) {
if(hovered_code) {
mainGame->ShowCardInfo(hovered_code);
}
if(pre_code)
imageManager.RemoveTexture(pre_code);
}
break;
}
case irr::EMIE_MOUSE_WHEEL: {
if(!mainGame->scrFilter->isVisible())
break;
if(event.MouseInput.Wheel < 0) {
if(mainGame->scrFilter->getPos() < mainGame->scrFilter->getMax())
mainGame->scrFilter->setPos(mainGame->scrFilter->getPos() + 1);
} else {
if(mainGame->scrFilter->getPos() > 0)
mainGame->scrFilter->setPos(mainGame->scrFilter->getPos() - 1);
}
SEvent e = event;
e.MouseInput.Event = irr::EMIE_MOUSE_MOVED;
mainGame->device->postEventFromUser(e);
break;
}
default:
break;
}
break;
}
case irr::EET_KEY_INPUT_EVENT: {
switch(event.KeyInput.Key) {
case irr::KEY_KEY_R: {
if(!event.KeyInput.PressedDown && !mainGame->HasFocus(EGUIET_EDIT_BOX))
mainGame->textFont->setTransparency(true);
break;
}
case irr::KEY_ESCAPE: {
if(!mainGame->HasFocus(EGUIET_EDIT_BOX))
mainGame->device->minimizeWindow();
break;
}
default:
break;
}
break;
}
default:
break;
}
return false;
}
static Log4gAppender *
parse_appender(Log4gConfigurator *base, xmlNodePtr node)
{
xmlChar *name = NULL;
Log4gAppender *appender = NULL;
struct Private *priv = GET_PRIVATE(base);
xmlChar *type = xmlGetProp(node, (const xmlChar *)"type");
if (type) {
GType gtype = g_type_from_name((const gchar *)type);
if (!gtype) {
log4g_log_error(Q_("%s: invalid `type'"), type);
goto exit;
}
if (!G_TYPE_IS_INSTANTIATABLE(gtype)) {
log4g_log_error(Q_("%s: is a non-instantiable type"),
type);
goto exit;
}
appender = g_object_new(gtype, NULL);
if (!appender) {
log4g_log_error(Q_("%s: g_object_new() returned NULL"),
type);
goto exit;
}
if (!LOG4G_IS_APPENDER(appender)) {
log4g_log_error(Q_("%s: not an instance of "
"Log4gAppender"), type);
g_object_unref(appender);
appender = NULL;
goto exit;
}
}
name = xmlGetProp(node, (const xmlChar *)"name");
if (appender) {
if (name) {
g_object_ref(appender);
g_hash_table_insert(priv->appenders, name, appender);
name = NULL;
}
} else {
if (name) {
appender = LOG4G_APPENDER(g_hash_table_lookup(
priv->appenders, name));
if (!appender) {
log4g_log_error(Q_("%s: no such appender"),
name);
goto exit;
}
g_object_ref(appender);
} else {
log4g_log_error(Q_("appenders without a `type' must "
"have a `name'"));
goto exit;
}
}
node = node->xmlChildrenNode;
while (node) {
if (!xmlStrcmp(node->name, (const xmlChar *)"property")) {
parse_property(base, node, appender);
} else if (!xmlStrcmp(node->name, (const xmlChar *)"layout")) {
Log4gLayout *layout = parse_layout(base, node);
if (layout) {
log4g_appender_set_layout(appender, layout);
g_object_unref(layout);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"filter")) {
Log4gFilter *filter = parse_filter(base, node);
if (filter) {
log4g_appender_add_filter(appender, filter);
g_object_unref(filter);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"appender")) {
if (LOG4G_IS_APPENDER_ATTACHABLE(appender)) {
Log4gAppender *child =
parse_appender(base, node);
if (child) {
log4g_appender_attachable_add_appender(
LOG4G_APPENDER_ATTACHABLE(appender),
child);
g_object_unref(child);
}
} else {
log4g_log_error(Q_("%s: does not implement "
"log4g_appender_attachable"),
type);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"text")) {
log4g_log_warn(Q_("invalid text element"));
} else if (!xmlStrcmp(node->name, (const xmlChar *)"comment")) {
/* do nothing */
} else {
log4g_log_warn(Q_("%s: invalid element"), node->name);
}
node = node->next;
}
if (log4g_appender_requires_layout(appender)
&& !log4g_appender_get_layout(appender)) {
log4g_log_error(Q_("%s: appender requires a layout"), type);
g_hash_table_remove(priv->appenders,
log4g_appender_get_name(appender));
g_object_unref(appender);
appender = NULL;
goto exit;
}
log4g_appender_activate_options(appender);
exit:
if (type) {
xmlFree(type);
}
if (name) {
xmlFree(name);
}
return appender;
}
inline filter parse_filter(const CharT* str)
{
return parse_filter(str, str + std::char_traits< CharT >::length(str));
}
inline filter parse_filter(std::basic_string< CharT, TraitsT, AllocatorT > const& str)
{
const CharT* p = str.c_str();
return parse_filter(p, p + str.size());
}
static int
parse_keys(bool wc_keys)
{
int exit_code = 0;
struct ds in;
ds_init(&in);
vlog_set_levels_from_string_assert("odp_util:console:dbg");
while (!ds_get_test_line(&in, stdin)) {
enum odp_key_fitness fitness;
struct ofpbuf odp_key;
struct ofpbuf odp_mask;
struct flow flow;
struct ds out;
int error;
/* Convert string to OVS DP key. */
ofpbuf_init(&odp_key, 0);
ofpbuf_init(&odp_mask, 0);
error = odp_flow_from_string(ds_cstr(&in), NULL,
&odp_key, &odp_mask);
if (error) {
printf("odp_flow_from_string: error\n");
goto next;
}
if (!wc_keys) {
struct odp_flow_key_parms odp_parms = {
.flow = &flow,
.recirc = true,
};
/* Convert odp_key to flow. */
fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
switch (fitness) {
case ODP_FIT_PERFECT:
break;
case ODP_FIT_TOO_LITTLE:
printf("ODP_FIT_TOO_LITTLE: ");
break;
case ODP_FIT_TOO_MUCH:
printf("ODP_FIT_TOO_MUCH: ");
break;
case ODP_FIT_ERROR:
printf("odp_flow_key_to_flow: error\n");
goto next;
}
/* Convert cls_rule back to odp_key. */
ofpbuf_uninit(&odp_key);
ofpbuf_init(&odp_key, 0);
odp_parms.odp_in_port = flow.in_port.odp_port;
odp_flow_key_from_flow(&odp_parms, &odp_key);
if (odp_key.size > ODPUTIL_FLOW_KEY_BYTES) {
printf ("too long: %"PRIu32" > %d\n",
odp_key.size, ODPUTIL_FLOW_KEY_BYTES);
exit_code = 1;
}
}
/* Convert odp_key to string. */
ds_init(&out);
if (wc_keys) {
odp_flow_format(odp_key.data, odp_key.size,
odp_mask.data, odp_mask.size, NULL, &out, false);
} else {
odp_flow_key_format(odp_key.data, odp_key.size, &out);
}
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_key);
}
ds_destroy(&in);
return exit_code;
}
static int
parse_actions(void)
{
struct ds in;
ds_init(&in);
vlog_set_levels_from_string_assert("odp_util:console:dbg");
while (!ds_get_test_line(&in, stdin)) {
struct ofpbuf odp_actions;
struct ds out;
int error;
/* Convert string to OVS DP actions. */
ofpbuf_init(&odp_actions, 0);
error = odp_actions_from_string(ds_cstr(&in), NULL, &odp_actions);
if (error) {
printf("odp_actions_from_string: error\n");
goto next;
}
/* Convert odp_actions back to string. */
ds_init(&out);
format_odp_actions(&out, odp_actions.data, odp_actions.size);
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_actions);
}
ds_destroy(&in);
return 0;
}
static int
parse_filter(char *filter_parse)
{
struct ds in;
struct flow flow_filter;
struct flow_wildcards wc_filter;
char *error, *filter = NULL;
vlog_set_levels_from_string_assert("odp_util:console:dbg");
if (filter_parse && !strncmp(filter_parse, "filter=", 7)) {
filter = xstrdup(filter_parse + 7);
memset(&flow_filter, 0, sizeof(flow_filter));
memset(&wc_filter, 0, sizeof(wc_filter));
error = parse_ofp_exact_flow(&flow_filter, &wc_filter.masks, filter,
NULL);
if (error) {
ovs_fatal(0, "Failed to parse filter (%s)", error);
}
} else {
ovs_fatal(0, "No filter to parse.");
}
ds_init(&in);
while (!ds_get_test_line(&in, stdin)) {
struct ofpbuf odp_key;
struct ofpbuf odp_mask;
struct ds out;
int error;
/* Convert string to OVS DP key. */
ofpbuf_init(&odp_key, 0);
ofpbuf_init(&odp_mask, 0);
error = odp_flow_from_string(ds_cstr(&in), NULL,
&odp_key, &odp_mask);
if (error) {
printf("odp_flow_from_string: error\n");
goto next;
}
if (filter) {
struct flow flow;
struct flow_wildcards wc;
struct match match, match_filter;
struct minimatch minimatch;
odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
odp_flow_key_to_mask(odp_mask.data, odp_mask.size, &wc.masks,
&flow);
match_init(&match, &flow, &wc);
match_init(&match_filter, &flow_filter, &wc);
match_init(&match_filter, &match_filter.flow, &wc_filter);
minimatch_init(&minimatch, &match_filter);
if (!minimatch_matches_flow(&minimatch, &match.flow)) {
minimatch_destroy(&minimatch);
goto next;
}
minimatch_destroy(&minimatch);
}
/* Convert odp_key to string. */
ds_init(&out);
odp_flow_format(odp_key.data, odp_key.size,
odp_mask.data, odp_mask.size, NULL, &out, false);
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_key);
ofpbuf_uninit(&odp_mask);
}
ds_destroy(&in);
free(filter);
return 0;
}
static void
test_odp_main(int argc, char *argv[])
{
int exit_code = 0;
set_program_name(argv[0]);
if (argc == 2 &&!strcmp(argv[1], "parse-keys")) {
exit_code =parse_keys(false);
} else if (argc == 2 &&!strcmp(argv[1], "parse-wc-keys")) {
exit_code =parse_keys(true);
} else if (argc == 2 && !strcmp(argv[1], "parse-actions")) {
exit_code = parse_actions();
} else if (argc == 3 && !strcmp(argv[1], "parse-filter")) {
exit_code =parse_filter(argv[2]);
} else {
ovs_fatal(0, "usage: %s parse-keys | parse-wc-keys | parse-actions", argv[0]);
}
exit(exit_code);
}
/*
* -- query_parse()
*
* Takes an http-like request and formats a message in the standard format
* GET ?module=xxx&start=xxx&end=xxx&other HTTP/1.x
*/
static qreq_t *
query_parse(char *buf, timestamp_t now)
{
static qreq_t q;
int max_args, nargs;
char *p, *p1, *end;
/*
* do a first pass to figure out how much space we need
* to store all the request parameters (i.e. args strings)
*
* NOTE: max_args will always be at least one (i.e., the NULL entry
* to indicate end of the arguments).
*/
max_args = 0;
p = buf;
do {
p = strchr(p+1, '&');
max_args++;
} while (p != NULL && strlen(p) > 1);
/* allocate a new request data structures */
q.args = safe_calloc(max_args, sizeof(char *));
nargs = 0;
/* provide some default values */
q.len = sizeof(q);
q.start = TS2SEC(now) - 50;
q.end = TS2SEC(now) + 20;
q.format = Q_OTHER;
q.wait = 1;
q.source = NULL;
/*
* check if the request is valid. look for GET and HTTP/1
* somewhere in the string.
*/
if (strstr(buf, "GET") != buf) {
logmsg(LOGQUERY, "Malformed request %s\n", buf);
return NULL;
}
end = strstr(buf, "HTTP/1");
if (end == NULL) {
logmsg(LOGQUERY, "Malformed request %s\n", buf);
return NULL;
}
/* mark the end of the useful string. walk backwards and
* remove any space at the end of the HTTP request.
*/
*end = '\0';
for (; end > buf && index(" \t", *end) != NULL; end--)
*end = '\0';
/* after GET we expect whitespace then a string */
for (p = buf + 3; *p && index(" \t", *p) != NULL; p++)
;
if (p == buf+3 || *p == '\0') {
logmsg(LOGQUERY, "Malformed request %s\n", buf);
return NULL;
}
for (; *p > ' ' && *p != '?'; p++)
;
if (*p != '?') {
/* invalid module, but do not fail so we return a 'not found' */
logmsg(LOGQUERY, "Malformed request %s\n", buf);
return NULL;
}
logmsg(V_LOGQUERY, "Good request %s\n", p);
p = urldecode(p);
while ( (p1 = strsep(&p, "?&")) != NULL) {
logmsg(V_LOGQUERY, "Token %s %s\n", p1, p);
if (p == p1+1) /* empty string */
;
else if (strstr(p1, "module=") == p1) {
char * s = strchr(p1, '=');
asprintf(&q.module, "%s", s + 1);
} else if (strstr(p1, "filter=") == p1) {
char * s = strchr(p1, '=');
q.filter_str = strdup(s + 1);
parse_filter(s + 1, NULL, &(q.filter_cmp));
} else if (strstr(p1, "start=") == p1) {
q.start = atoi(p1+6);
} else if (strstr(p1, "end=") == p1) {
q.end = atoi(p1+4);
} else if (strstr(p1, "format=raw") == p1) {
q.format = Q_RAW;
} else if (strstr(p1, "format=como") == p1) {
q.format = Q_COMO;
} else if (strstr(p1, "format=html") == p1) {
q.format = Q_HTML;
/* we forward this to the module */
q.args[nargs] = strdup(p1);
nargs++;
assert(nargs < max_args);
} else if (strstr(p1, "wait=no") == p1) {
q.wait = 0;
} else if (strstr(p1, "status") == p1) {
q.format = Q_STATUS;
} else if (strstr(p1, "time=") == p1) {
timestamp_t current;
char * str;
current = now;
str = index(p1, '=') + 1;
q.start = parse_timestr(str, ¤t);
str = index(p1, ':') + 1;
q.end = parse_timestr(str, ¤t);
} else if (strstr(p1, "source=") == p1) {
char * s = strchr(p1, '=');
q.source = strdup(s + 1);
} else {
logmsg(V_LOGQUERY, "custom argument: %s\n", p1);
q.args[nargs] = strdup(p1);
nargs++;
assert(nargs < max_args);
}
}
return &q;
}
int main(int argc, char *argv[])
{
int dmxfd;
unsigned long pid, tid;
char * dmxdev = "/dev/dvb/adapter0/demux0";
unsigned char filter[DMX_FILTER_SIZE];
unsigned char mask[DMX_FILTER_SIZE];
int filter_idx;
if (argc < 2 || argc > 5)
usage();
pid = strtoul(argv[1], NULL, 0);
if (pid > 0x1fff)
usage();
if (argc > 2) {
tid = strtoul(argv[2], NULL, 0);
if (tid > 0xff)
usage();
} else
tid = 0x100;
if (argc > 3)
parse_filter(filter, argv[3]);
else
memset(filter, '\0', sizeof(filter));
if (argc > 4)
parse_filter(mask, argv[4]);
else
memset(mask, '\0', sizeof(mask));
if (tid < 0x100) {
filter[0] = tid;
mask[0] = 0xff;
}
if (getenv("DEMUX"))
dmxdev = getenv("DEMUX");
fprintf(stderr, "test_sections: using '%s'\n", dmxdev);
fprintf(stderr, " PID 0x%04lx\n", pid);
if (tid < 0x100)
fprintf(stderr, " TID 0x%02lx\n", tid);
fprintf(stderr, " Filter ");
for (filter_idx = 0; filter_idx < DMX_FILTER_SIZE; ++filter_idx)
fprintf(stderr, "0x%.2x ", filter[filter_idx]);
fprintf(stderr, "\n");
fprintf(stderr, " Mask ");
for (filter_idx = 0; filter_idx < DMX_FILTER_SIZE; ++filter_idx)
fprintf(stderr, "0x%.2x ", mask[filter_idx]);
fprintf(stderr, "\n");
if ((dmxfd = open(dmxdev, O_RDWR)) < 0){
perror("open");
return 1;
}
if (set_filter(dmxfd, pid, filter, mask) != 0)
return 1;
for (;;) {
process_section(dmxfd);
}
close(dmxfd);
return 0;
}
