static DBusMessage *pbap_set_filter(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct pbap_data *pbap = user_data;
char **filters, **item;
gint size;
uint64_t oldfilter = pbap->filter;
if (dbus_message_get_args(message, NULL, DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING, &filters, &size,
DBUS_TYPE_INVALID) == FALSE)
return g_dbus_create_error(message,
ERROR_INF ".InvalidArguments", NULL);
remove_filter(pbap, "ALL");
if (size == 0)
goto done;
for (item = filters; *item; item++) {
if (add_filter(pbap, *item) < 0) {
pbap->filter = oldfilter;
g_strfreev(filters);
return g_dbus_create_error(message,
ERROR_INF ".InvalidArguments", "InvalidFilters");
}
}
done:
g_strfreev(filters);
return dbus_message_new_method_return(message);
}
/*
=================
G_ListIP_f
=================
*/
void G_ListIP_f(edict_t *ent)
{
byte b[4];
ipfilter_t *ip, *next;
char address[32], expires[32];
time_t now, diff;
if (LIST_EMPTY(&ipfilters)) {
gi.cprintf(ent, PRINT_HIGH, "Filter list is empty.\n");
return;
}
now = time(NULL);
gi.cprintf(ent, PRINT_HIGH,
"address expires in action added by\n"
"--------------- ---------- ------ ---------------\n");
FOR_EACH_IPFILTER_SAFE(ip, next) {
*(unsigned *)b = ip->compare;
Q_snprintf(address, sizeof(address), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
if (ip->duration) {
diff = now - ip->added;
if (diff > ip->duration) {
remove_filter(ip);
continue;
}
Com_FormatTime(expires, sizeof(expires), ip->duration - diff);
} else {
strcpy(expires, "permanent");
}
gi.cprintf(ent, PRINT_HIGH, "%-15s %10s %6s %s\n",
address, expires, ip->action == IPA_MUTE ? "mute" : "ban", ip->adder);
}
/*
=================
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);
}
/*
=================
G_CheckFilters
=================
*/
ipaction_t G_CheckFilters(char *s)
{
int i;
unsigned in;
byte m[4] = { 0 };
char *p;
time_t now;
ipfilter_t *ip, *next;
for (i = 0; i < 4; i++) {
m[i] = strtoul(s, &p, 10);
if (s == p || !*p || *p == ':')
break;
s = p + 1;
}
in = *(unsigned *)m;
now = time(NULL);
FOR_EACH_IPFILTER_SAFE(ip, next) {
if (ip->duration && now - ip->added > ip->duration) {
remove_filter(ip);
continue;
}
if ((in & ip->mask) == ip->compare) {
return ip->action; //(int)filterban->value ? ip->action : IPA_NONE;
}
}
return IPA_NONE; //(int)filterban->value ? IPA_NONE : IPA_BAN;
}
void LogstorageConfigCreatorForm::on_pushButton_Delete_clicked()
{
remove_filter(false);
// make index 0 active
ui->comboBox_filter->setCurrentIndex(0);
load_filter(0);
}
void LogstorageConfigCreatorForm::on_pushButton_Add_clicked()
{
if (validateFilter())
{
LogstorageFilter filter;
if(filters->contains(ui->comboBox_filter->currentText())) /* remove filter */
{
/* store current position in textedit */
ui->textEdit->setFocus();
QTextCursor storeCursorPos = ui->textEdit->textCursor();
remove_filter(true);
filter.setApid(ui->lineEdit_apid->text());
filter.setCtid(ui->lineEdit_ctid->text());
filter.setLogLevel(ui->comboBox_level->currentText());
filter.setFileName(ui->lineEdit_fname->text());
filter.setFileSize(ui->lineEdit_fsize->text().toInt());
filter.setNoFiles(ui->lineEdit_nofiles->text().toInt());
filters->insert(ui->comboBox_filter->currentText(), filter);
ui->textEdit->textCursor().insertText(filterToText(ui->comboBox_filter->currentText()));
ui->textEdit->textCursor().insertText(QString("\n"));
ui->textEdit->textCursor().insertText(filter.toText());
/* reset courser */
ui->textEdit->setTextCursor(storeCursorPos);
}
else /* add a new at the end */
{
ui->textEdit->moveCursor(QTextCursor::End);
filter.setApid(ui->lineEdit_apid->text());
filter.setCtid(ui->lineEdit_ctid->text());
filter.setLogLevel(ui->comboBox_level->currentText());
filter.setFileName(ui->lineEdit_fname->text());
filter.setFileSize(ui->lineEdit_fsize->text().toInt());
filter.setNoFiles(ui->lineEdit_nofiles->text().toInt());
filters->insert(ui->comboBox_filter->currentText(), filter);
ui->textEdit->textCursor().insertText(filterToText(ui->comboBox_filter->currentText()));
ui->textEdit->textCursor().insertText(QString("\n"));
ui->textEdit->textCursor().insertText(filter.toText());
ui->textEdit->textCursor().insertText(QString("\n"));
}
// update "Add" to "Update" text of Add button
set_button_text_Add_to_Update(0);
}
}
void cmd_simple_config(int argc, char **argv){
#if CONFIG_INCLUDE_SIMPLE_CONFIG
char *custom_pin_code = NULL;
int ret = SC_ERROR;
if(argc > 2){
printf("\n\rInput Error!");
}
if(argc == 2)
custom_pin_code = (argv[1]);
wifi_enter_promisc_mode();
if(init_test_data(custom_pin_code) == 0){
filter_add_enable();
ret = simple_config_test();
print_simple_config_result(ret);
remove_filter();
}
#endif
}
int32_t coolapi_remove_filter(int32_t fd, int32_t num)
{
void * channel = NULL;
void * filter = NULL;
dmx_t *dmx = find_demux(fd, 0);
if(!dmx)
{
cs_log_dbg(D_DVBAPI, "dmx is NULL!");
return -1;
}
if(dmx->pid <= 0)
{ return -1; }
int32_t result;
SAFE_MUTEX_LOCK(&dmx->mutex);
// Find matching channel, if it exists.
S_COOL_CHANHANDLE *handle_item = find_chanhandle(COOLDEMUX_DMX_DEV(fd), dmx->pid);
if (!handle_item)
{
SAFE_MUTEX_UNLOCK(&dmx->mutex);
cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04xcfailed, channel does not exist.", fd, num, dmx->pid);
return -1;
}
channel = handle_item->channel;
cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04x on channel=%p", fd, num, dmx->pid, channel);
S_COOL_FILTER *filter_item = find_filter_by_chanhandle(handle_item, num);
if(filter_item)
{
result = cnxt_dmx_channel_suspend(channel, 1);
coolapi_check_error("cnxt_dmx_channel_suspend", result);
result = cnxt_dmx_channel_detach_filter(channel, filter_item->filter);
coolapi_check_error("cnxt_dmx_channel_detach_filter", result);
#if 0
result = cnxt_dmx_close_filter(filter_item->filter);
coolapi_check_error("cnxt_dmx_close_filter", result);
#endif
filter = filter_item->filter;
remove_filter(filter_item);
handle_item->allocated_filters--;
}
else
{
SAFE_MUTEX_UNLOCK(&dmx->mutex);
cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04x on channel=%x failed, channel does not exist.", fd, num, dmx->pid, (int32_t) handle_item->channel);
return -1;
}
if (!handle_item->allocated_filters)
{
result = cnxt_dmx_channel_ctrl(channel, 0, 0);
coolapi_check_error("cnxt_dmx_channel_ctrl", result);
cs_log_dbg(D_DVBAPI, "closing channel %x", (int32_t) channel);
result = cnxt_dmx_set_channel_pid(channel, 0x1FFF);
coolapi_check_error("cnxt_dmx_set_channel_pid", result);
result = cnxt_cbuf_flush(handle_item->buffer1, 0);
coolapi_check_error("cnxt_cbuf_flush", result);
result = cnxt_cbuf_flush(handle_item->buffer2, 0);
coolapi_check_error("cnxt_cbuf_flush", result);
result = cnxt_cbuf_detach(handle_item->buffer2, 2, channel);
coolapi_check_error("cnxt_cbuf_detach", result);
result = cnxt_dmx_channel_detach(channel, 0xB, 0, handle_item->buffer1);
coolapi_check_error("cnxt_dmx_channel_detach", result);
#if 0
result = cnxt_dmx_channel_close(channel);
coolapi_check_error("cnxt_dmx_channel_close", result);
#endif
result = cnxt_cbuf_close(handle_item->buffer2);
coolapi_check_error("cnxt_cbuf_close", result);
result = cnxt_cbuf_close(handle_item->buffer1);
coolapi_check_error("cnxt_cbuf_close", result);
handle_item->channel = NULL;
handle_item->buffer1 = NULL;
handle_item->buffer2 = NULL;
remove_chanhandle(handle_item);
dmx_handles[COOLDEMUX_DMX_DEV(fd)].allocated_channels--;
dmx->pid = -1;
} else {
result = cnxt_dmx_channel_suspend(channel, 0);
coolapi_check_error("cnxt_dmx_channel_suspend", result);
channel = NULL;
}
SAFE_MUTEX_UNLOCK(&dmx->mutex);
if (filter) {
result = cnxt_dmx_close_filter(filter);
coolapi_check_error("cnxt_dmx_close_filter", result);
}
if (channel) {
result = cnxt_dmx_channel_close(channel);
coolapi_check_error("cnxt_dmx_channel_close", result);
}
return 0;
}
void
ObjectCompositeSettings::_blendBlurValueChanged()
{
if (!_subject) {
return;
}
SPDesktop *desktop = _subject->getDesktop();
if (!desktop) {
return;
}
SPDocument *document = sp_desktop_document (desktop);
if (_blocked)
return;
_blocked = true;
// FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed; here it results in crash 1580903
//sp_canvas_force_full_redraw_after_interruptions(sp_desktop_canvas(desktop), 0);
Geom::OptRect bbox = _subject->getBounds(SPItem::GEOMETRIC_BBOX);
double radius;
if (bbox) {
double perimeter = bbox->dimensions()[Geom::X] + bbox->dimensions()[Geom::Y]; // fixme: this is only half the perimeter, is that correct?
radius = _fe_cb.get_blur_value() * perimeter / 400;
} else {
radius = 0;
}
const Glib::ustring blendmode = _fe_cb.get_blend_mode();
//apply created filter to every selected item
for (StyleSubject::iterator i = _subject->begin() ; i != _subject->end() ; ++i ) {
if (!SP_IS_ITEM(*i)) {
continue;
}
SPItem * item = SP_ITEM(*i);
SPStyle *style = item->style;
g_assert(style != NULL);
if (blendmode != "normal") {
SPFilter *filter = new_filter_simple_from_item(document, item, blendmode.c_str(), radius);
sp_style_set_property_url(item, "filter", filter, false);
} else {
sp_style_set_property_url(item, "filter", NULL, false);
}
if (radius == 0 && item->style->filter.set
&& filter_is_single_gaussian_blur(SP_FILTER(item->style->getFilter()))) {
remove_filter(item, false);
}
else if (radius != 0) {
SPFilter *filter = modify_filter_gaussian_blur_from_item(document, item, radius);
sp_style_set_property_url(item, "filter", filter, false);
}
//request update
item->requestDisplayUpdate(( SP_OBJECT_MODIFIED_FLAG |
SP_OBJECT_STYLE_MODIFIED_FLAG ));
}
DocumentUndo::maybeDone(document, _blur_tag.c_str(), _verb_code,
_("Change blur"));
// resume interruptibility
//sp_canvas_end_forced_full_redraws(sp_desktop_canvas(desktop));
_blocked = false;
}
int av_asrc_buffer_add_audio_buffer_ref(AVFilterContext *ctx,
AVFilterBufferRef *samplesref,
int av_unused flags)
{
ABufferSourceContext *abuffer = ctx->priv;
AVFilterLink *link;
int ret, logged = 0;
if (av_fifo_space(abuffer->fifo) < sizeof(samplesref)) {
av_log(ctx, AV_LOG_ERROR,
"Buffering limit reached. Please consume some available frames "
"before adding new ones.\n");
return AVERROR(EINVAL);
}
// Normalize input
link = ctx->outputs[0];
if (samplesref->audio->sample_rate != link->sample_rate) {
log_input_change(ctx, link, samplesref);
logged = 1;
abuffer->sample_rate = samplesref->audio->sample_rate;
if (!abuffer->aresample) {
ret = insert_filter(abuffer, link, &abuffer->aresample, "aresample");
if (ret < 0) return ret;
} else {
link = abuffer->aresample->outputs[0];
if (samplesref->audio->sample_rate == link->sample_rate)
remove_filter(&abuffer->aresample);
else
if ((ret = reconfigure_filter(abuffer, abuffer->aresample)) < 0)
return ret;
}
}
link = ctx->outputs[0];
if (samplesref->format != link->format ||
samplesref->audio->channel_layout != link->channel_layout ||
samplesref->audio->planar != link->planar) {
if (!logged) log_input_change(ctx, link, samplesref);
abuffer->sample_format = samplesref->format;
abuffer->channel_layout = samplesref->audio->channel_layout;
abuffer->packing_format = samplesref->audio->planar;
if (!abuffer->aconvert) {
ret = insert_filter(abuffer, link, &abuffer->aconvert, "aconvert");
if (ret < 0) return ret;
} else {
link = abuffer->aconvert->outputs[0];
if (samplesref->format == link->format &&
samplesref->audio->channel_layout == link->channel_layout &&
samplesref->audio->planar == link->planar
)
remove_filter(&abuffer->aconvert);
else
if ((ret = reconfigure_filter(abuffer, abuffer->aconvert)) < 0)
return ret;
}
}
if (sizeof(samplesref) != av_fifo_generic_write(abuffer->fifo, &samplesref,
sizeof(samplesref), NULL)) {
av_log(ctx, AV_LOG_ERROR, "Error while writing to FIFO\n");
return AVERROR(EINVAL);
}
return 0;
}
