static PyObject *
init_filters(void)
{
PyObject *filters = PyList_New(3);
const char *bytes_action;
if (filters == NULL)
return NULL;
PyList_SET_ITEM(filters, 0,
create_filter(PyExc_PendingDeprecationWarning, "ignore"));
PyList_SET_ITEM(filters, 1, create_filter(PyExc_ImportWarning, "ignore"));
if (Py_BytesWarningFlag > 1)
bytes_action = "error";
else if (Py_BytesWarningFlag)
bytes_action = "default";
else
bytes_action = "ignore";
PyList_SET_ITEM(filters, 2, create_filter(PyExc_BytesWarning,
bytes_action));
if (PyList_GET_ITEM(filters, 0) == NULL ||
PyList_GET_ITEM(filters, 1) == NULL ||
PyList_GET_ITEM(filters, 2) == NULL) {
Py_DECREF(filters);
return NULL;
}
return filters;
}
/*******************************************************************************
* int multiply_filters(d_filter_t f1, d_filter_t f2, d_filter_t* out)
*
*
*******************************************************************************/
int multiply_filters(d_filter_t f1, d_filter_t f2, d_filter_t* out){
if(f1.initialized!=1 || f2.initialized!=1){
printf("ERROR: filter not initialized\n");
return -1;
}
if(f1.dt != f2.dt){
printf("ERROR: filter timestep dt must match when multiplying.\n");
return -1;
}
// order of new system is sum of old orders
int new_order = f1.order + f2.order;
// multiply out the transfer function coefficients
vector_t newnum,newden;
if(polynomial_convolution(f1.numerator,f2.numerator,&newnum)<0){
printf("ERROR:failed to multiply numerator polynomials\n");
return -1;
}
if(polynomial_convolution(f1.denominator,f2.denominator,&newden)<0){
printf("ERROR:failed to multiply denominator polynomials\n");
return -1;
}
*out = create_filter(new_order, f1.dt, &newnum.data[0], &newden.data[0]);
return 0;
}
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;
}
image_p image_scale(image_p src, int w, int h,int mode)
{
image_p dst;
uint8 * temp;
uint8 recover = 0;
uint32 spitch, dpitch;
filter_base* filter = create_filter(mode);
dst = image_create(w,h,src->dtype);
dst->dontswizzle = 1;
if(src->swizzle ==1){
unswizzle_swap(src);
recover = 1;
}
temp = malloc(dst->w*src->h*src->bpb);
memset(temp,0,dst->w*src->h*src->bpb);
spitch = src->texw;
dpitch = dst->texw;
horiz_scale(filter,src->data,src->w,src->h,temp,dst->w,src->h,spitch,src->dtype);
vert_scale (filter,temp,dst->w,src->h,dst->data,dst->w,dst->h,dpitch,src->dtype);
free(temp);
destroy_filter(filter);
if(recover)
swizzle_swap(src);
return dst;
}
static void attach_normalisers( mlt_profile profile, mlt_producer producer )
{
// Loop variable
int i;
// Tokeniser
mlt_tokeniser tokeniser = mlt_tokeniser_init( );
// We only need to load the normalising properties once
if ( normalisers == NULL )
{
char temp[ 1024 ];
sprintf( temp, "%s/core/loader.ini", mlt_environment( "MLT_DATA" ) );
normalisers = mlt_properties_load( temp );
mlt_factory_register_for_clean_up( normalisers, ( mlt_destructor )mlt_properties_close );
}
// Apply normalisers
for ( i = 0; i < mlt_properties_count( normalisers ); i ++ )
{
int j = 0;
int created = 0;
char *value = mlt_properties_get_value( normalisers, i );
mlt_tokeniser_parse_new( tokeniser, value, "," );
for ( j = 0; !created && j < mlt_tokeniser_count( tokeniser ); j ++ )
create_filter( profile, producer, mlt_tokeniser_get_string( tokeniser, j ), &created );
}
// Close the tokeniser
mlt_tokeniser_close( tokeniser );
}
/*******************************************************************************
* d_filter_t create_butterworth_highpass(int order, float dt, float wc)
*
* Returns a configured and ready to use d_filter_t_t struct with the transfer
* function for Butterworth low pass filter of order N and cutoff wc.
*******************************************************************************/
d_filter_t create_butterworth_highpass(int order, float dt, float wc){
vector_t A = poly_butter(order,wc);
vector_t B = create_vector(order + 1);
B.data[0] = 1;
vector_t Bz, Az;
C2DTustin(B, A, &Bz, &Az, dt, wc);
return create_filter(order, dt, Bz.data, Az.data);
}
static PyObject *
init_filters(void)
{
PyObject *filters = PyList_New(5);
unsigned int pos = 0; /* Post-incremented in each use. */
unsigned int x;
const char *bytes_action, *resource_action;
if (filters == NULL)
return NULL;
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_DeprecationWarning, "ignore"));
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_PendingDeprecationWarning, "ignore"));
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_ImportWarning, "ignore"));
if (Py_BytesWarningFlag > 1)
bytes_action = "error";
else if (Py_BytesWarningFlag)
bytes_action = "default";
else
bytes_action = "ignore";
PyList_SET_ITEM(filters, pos++, create_filter(PyExc_BytesWarning,
bytes_action));
/* resource usage warnings are enabled by default in pydebug mode */
#ifdef Py_DEBUG
resource_action = "always";
#else
resource_action = "ignore";
#endif
PyList_SET_ITEM(filters, pos++, create_filter(PyExc_ResourceWarning,
resource_action));
for (x = 0; x < pos; x += 1) {
if (PyList_GET_ITEM(filters, x) == NULL) {
Py_DECREF(filters);
return NULL;
}
}
return filters;
}
static PyObject *
init_filters(void)
{
/* Don't silence DeprecationWarning if -3 or -Q were used. */
PyObject *filters = PyList_New(Py_Py3kWarningFlag ||
Py_DivisionWarningFlag ? 3 : 4);
unsigned int pos = 0; /* Post-incremented in each use. */
unsigned int x;
const char *bytes_action;
if (filters == NULL)
return NULL;
/* If guard changes, make sure to update 'filters' initialization above. */
if (!Py_Py3kWarningFlag && !Py_DivisionWarningFlag) {
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_DeprecationWarning, "ignore"));
}
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_PendingDeprecationWarning, "ignore"));
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_ImportWarning, "ignore"));
if (Py_BytesWarningFlag > 1)
bytes_action = "error";
else if (Py_BytesWarningFlag)
bytes_action = "default";
else
bytes_action = "ignore";
PyList_SET_ITEM(filters, pos++, create_filter(PyExc_BytesWarning,
bytes_action));
for (x = 0; x < pos; x += 1) {
if (PyList_GET_ITEM(filters, x) == NULL) {
Py_DECREF(filters);
return NULL;
}
}
return filters;
}
/**
* \brief Builds the Rbc PF tracker
*/
std::shared_ptr<ParticleTracker> build()
{
auto filter = create_filter(object_model_, params_.max_kl_divergence);
auto tracker = std::make_shared<ParticleTracker>(
filter,
object_model_,
params_.evaluation_count,
params_.moving_average_update_rate,
params_.center_object_frame);
return tracker;
}
mlt_filter filter_movit_convert_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_filter filter = NULL;
GlslManager* glsl = GlslManager::get_instance();
if ( glsl && ( filter = mlt_filter_new() ) )
{
#ifdef WIN32
// XXX avcolor_space is crashing on Windows in this context!
mlt_filter cpu_csc = NULL;
#else
mlt_filter cpu_csc = create_filter( profile, "avcolor_space" );
#endif
if ( !cpu_csc )
cpu_csc = create_filter( profile, "imageconvert" );
if ( cpu_csc )
mlt_properties_set_data( MLT_FILTER_PROPERTIES( filter ), "cpu_csc", cpu_csc, 0,
(mlt_destructor) mlt_filter_close, NULL );
filter->process = process;
}
return filter;
}
dwgs :: dwgs(float f, float Fs, float Z, float Zb, float Zh)
{
this->f = f;
this->Fs = Fs;
int del = (int)(4.0*Fs/f);
if(f > 400) {
M = 1;
create_filter(&(dispersion[0]),2);
} else {
M = 4;
for(int m=0;m<M;m++)
create_filter(&(dispersion[m]),2);
}
create_filter(&lowpass,1);
create_filter(&fracdelay,8);
create_filter(&bottomfilter,9);
d[0] = new dwg(Z,del,del,0,this);
d[1] = new dwg(Z,del,del,1,this);
d[2] = new dwg(Zb,0,0,0,this);
d[3] = new dwg(Zh,0,0,0,this);
d[0]->connectRight(d[1]->l);
d[1]->connectLeft(d[0]->r);
d[1]->connectRight(d[2]->l);
d[2]->connectLeft(d[1]->r);
d[0]->connectRight(d[3]->l);
d[1]->connectLeft(d[3]->l);
d[3]->connectLeft(d[0]->r);
d[3]->connectLeft(d[1]->l);
d[0]->init();
d[1]->init();
d[2]->init();
d[3]->init();
}
/*******************************************************************************
* d_filter_t create_pid(float kp, float ki, float kd, float Tf, float dt)
*
* discrete-time implementation of a parallel PID controller with rolloff.
* This is equivalent to the Matlab function: C = pid(Kp,Ki,Kd,Tf,Ts)
*
* We cannot implement a pure differentiator with a discrete transfer function
* so this filter has high frequency rolloff with time constant Tf. Smaller Tf
* results in less rolloff, but Tf must be greater than dt/2 for stability.
*******************************************************************************/
d_filter_t create_pid(float kp, float ki, float kd, float Tf, float dt){
if(Tf <= dt/2){
printf("WARNING: Tf must be > dt/2 for stability\n");
Tf=dt; // set to reasonable value
}
// if ki==0, return a PD filter with rolloff
if(ki==0){
float numerator[] = {(kp*Tf+kd)/Tf,
-(((ki*dt-kp)*(dt-Tf))+kd)/Tf};
float denominator[] = {1,
-(Tf-dt)/Tf};
return create_filter(1,dt,numerator,denominator);
}
//otherwise PID with roll off
else{
float numerator[] = {(kp*Tf+kd)/Tf,
(ki*dt*Tf + kp*(dt-Tf) - kp*Tf - 2.0*kd)/Tf,
(((ki*dt-kp)*(dt-Tf))+kd)/Tf};
float denominator[] = {1,
(dt-(2.0*Tf))/Tf,
(Tf-dt)/Tf};
return create_filter(2,dt,numerator,denominator);
}
}
mlt_producer producer_loader_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
// Create the producer
mlt_producer producer = NULL;
mlt_properties properties = NULL;
if ( arg != NULL )
producer = create_producer( profile, arg );
if ( producer != NULL )
properties = MLT_PRODUCER_PROPERTIES( producer );
// Attach filters if we have a producer and it isn't already xml'd :-)
if ( producer && strcmp( id, "abnormal" ) &&
mlt_properties_get( properties, "xml" ) == NULL &&
mlt_properties_get( properties, "_xml" ) == NULL &&
mlt_properties_get( properties, "loader_normalised" ) == NULL )
attach_normalisers( profile, producer );
if ( producer )
{
// Always let the image and audio be converted
int created = 0;
create_filter( profile, producer, "avcolor_space", &created );
if ( !created )
create_filter( profile, producer, "imageconvert", &created );
create_filter( profile, producer, "audioconvert", &created );
}
// Now make sure we don't lose our identity
if ( properties != NULL )
mlt_properties_set_int( properties, "_mlt_service_hidden", 1 );
// Return the producer
return producer;
}
/**
* Parse a string of the form FILTER_NAME[=PARAMS], and create a
* corresponding filter instance which is added to graph with
* create_filter().
*
* @param filt_ctx put here a pointer to the created filter context on
* success, NULL otherwise
* @param buf pointer to the buffer to parse, *buf will be updated to
* point to the char next after the parsed string
* @param index an index which is assigned to the created filter
* instance, and which is supposed to be unique for each filter
* instance added to the filtergraph
* @return 0 in case of success, a negative AVERROR code otherwise
*/
static int parse_filter(AVFilterContext **filt_ctx, const char **buf, AVFilterGraph *graph,
int index, AVClass *log_ctx)
{
char *opts = NULL;
char *name = av_get_token(buf, "=,;[\n");
int ret;
if (**buf == '=') {
(*buf)++;
opts = av_get_token(buf, "[],;\n");
}
ret = create_filter(filt_ctx, graph, index, name, opts, log_ctx);
av_free(name);
av_free(opts);
return ret;
}
int update_filter(virConnectPtr conn, struct acl_filter *filter)
{
return create_filter(conn, filter);
}
/*******************************************************************************
* d_filter_t create_double_integrator(float dt)
*
* Returns a configured and ready to use d_filter_t_t struct with the transfer
* function for a first order time integral.
*******************************************************************************/
d_filter_t create_double_integrator(float dt){
float numerator[] = {0, 0, dt*dt};
float denominator[] = {1, -2, 1};
return create_filter(2,dt,numerator,denominator);
}
/*******************************************************************************
* d_filter_t create_integrator(float dt)
*
* Returns a configured and ready to use d_filter_t_t struct with the transfer
* function for a first order time integral.
*******************************************************************************/
d_filter_t create_integrator(float dt){
float numerator[] = {0, dt};
float denominator[] = {1, -1};
return create_filter(1,dt,numerator,denominator);
}
/*******************************************************************************
* d_filter_t create_first_order_high_pass(float dt, float time_constant)
*
* Returns a configured and ready to use d_filter_t_t struct with a first order
* high pass transfer function. dt is in units of seconds and time_constant is
* the number of seconds it takes to decay by 63.4% of a steady-state input.
*******************************************************************************/
d_filter_t create_first_order_high_pass(float dt, float time_constant){
float hp_const = dt/time_constant;
float numerator[] = {1-hp_const, hp_const-1};
float denominator[] = {1,hp_const-1};
return create_filter(1,dt,numerator,denominator);
}
void *ldap_table_search(struct ci_lookup_table *table, void *key, void ***vals)
{
struct ldap_table_data *data = (struct ldap_table_data *)table->data;
LDAPMessage *msg, *entry;
BerElement *aber;
LDAP *ld;
struct berval **attrs;
void *return_value=NULL;
char *attrname;
int ret = 0, failures, i;
ci_str_vector_t *vect = NULL;
size_t v_size;
char filter[MAX_LDAP_FILTER_SIZE];
char buf[2048];
*vals = NULL;
failures = 0;
return_value = NULL;
if(data->cache && ci_cache_search(data->cache, key, (void **)&vect, NULL, &ci_cache_read_vector_val)) {
ci_debug_printf(4, "Retrieving from cache....\n");
if (!vect) /*Negative hit*/
return NULL;
*vals = (void **)ci_vector_cast_to_voidvoid(vect);
return key;
}
create_filter(filter, MAX_LDAP_FILTER_SIZE, data->filter,key);
while ((ld = ldap_connection_open(data->pool)) && failures < 5) {
ret = ldap_search_ext_s(ld,
data->base, /*base*/
LDAP_SCOPE_SUBTREE, /*scope*/
filter, /*filter*/
data->attrs, /*attrs*/
0, /*attrsonly*/
NULL, /*serverctrls*/
NULL, /*clientctrls*/
NULL, /*timeout*/
-1, /*sizelimit*/
&msg /*res*/
);
ci_debug_printf(4, "Contacting LDAP server: %s\n", ldap_err2string(ret));
if(ret == LDAP_SUCCESS) {
entry = ldap_first_entry(ld, msg);
while(entry != NULL) {
aber = NULL;
attrname = ldap_first_attribute(ld, entry, &aber);
while(attrname != NULL) {
if (vect == NULL) {
vect = ci_str_vector_create(MAX_DATA_SIZE);
if (!vect)
return NULL;
}
ci_debug_printf(8, "Retrieve attribute:%s. Values: ", attrname);
attrs = ldap_get_values_len(ld, entry, attrname);
for(i = 0; attrs[i] != NULL ; ++i) {
//OpenLdap nowhere documents that the result is NULL terminated.
// copy to an intermediate buffer and terminate it before store to vector
v_size = sizeof(buf) <= attrs[i]->bv_len + 1 ? sizeof(buf) : attrs[i]->bv_len;
memcpy(buf, attrs[i]->bv_val, v_size);
buf[v_size] = '\0';
(void)ci_str_vector_add(vect, buf);
ci_debug_printf(8, "%s,", buf);
}
ci_debug_printf(8, "\n");
ldap_value_free_len(attrs);
attrname = ldap_next_attribute(ld, entry, aber);
}
if(aber)
ber_free(aber, 0);
if(!return_value)
return_value = key;
entry = ldap_next_entry(ld, entry);
}
ldap_msgfree(msg);
ldap_connection_release(data->pool, ld, 0);
if(data->cache) {
v_size = vect != NULL ? ci_cache_store_vector_size(vect) : 0;
ci_debug_printf(4, "adding to cache\n");
if (!ci_cache_update(data->cache, key, vect, v_size, ci_cache_store_vector_val))
ci_debug_printf(4, "adding to cache failed!\n");
}
if (!vect)
return NULL;
*vals = (void **)ci_vector_cast_to_voidvoid(vect);
return return_value;
}
ldap_connection_release(data->pool, ld, 1);
if (ret != LDAP_SERVER_DOWN) {
ci_debug_printf(1, "Error contacting LDAP server: %s\n", ldap_err2string(ret));
return NULL;
}
failures++;
}
ci_debug_printf(1, "Error LDAP server is down: %s\n", ldap_err2string(ret));
return NULL;
}
LRESULT album_list_window::on_message(HWND wnd, UINT msg, WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_CREATE:
{
list_wnd.add_item(this);
initialised = true;
modeless_dialog_manager::g_add(wnd);
create_tree();
create_filter();
if (cfg_populate) refresh_tree();
static_api_ptr_t<library_manager_v3>()->register_callback(this);
}
break;
/*case WM_GETMINMAXINFO:
{
LPMINMAXINFO mmi = LPMINMAXINFO(lp);
mmi->ptMinTrackSize.y = cfg_height;
return 0;
}*/
case WM_SIZE:
on_size(LOWORD(lp), HIWORD(lp));
break;
/* case DM_GETDEFID:
return (DC_HASDEFID<<16|IDOK);
case WM_GETDLGCODE:
return DLGC_DEFPUSHBUTTON;*/
// break;
case WM_TIMER:
if (wp == EDIT_TIMER_ID)
{
refresh_tree();
KillTimer(wnd, wp);
m_timer = false;
}
break;
case WM_COMMAND:
switch (wp)
{
case IDC_FILTER | (EN_CHANGE << 16) :
if (m_timer)
KillTimer(wnd_edit, 500);
m_timer = SetTimer(wnd, EDIT_TIMER_ID, 500, NULL) != 0;
return TRUE;
case IDOK:
if (GetKeyState(VK_SHIFT) & KF_UP) do_playlist(p_selection, false);
else if (GetKeyState(VK_CONTROL) & KF_UP) do_playlist(p_selection, true, true);
else do_playlist(p_selection, true);
return 0;
}
break;
case WM_CONTEXTMENU:
{
enum { ID_SEND = 1, ID_ADD, ID_NEW, ID_AUTOSEND, ID_REMOVE, ID_REMOVEDEAD, ID_REFRESH, ID_FILT, ID_CONF, ID_VIEW_BASE };
HMENU menu = CreatePopupMenu();
POINT pt = { GET_X_LPARAM(lp), GET_Y_LPARAM(lp) };
service_ptr_t<contextmenu_manager> p_menu_manager;
unsigned IDM_MANAGER_BASE = 0;
HWND list = wnd_tv;
HTREEITEM treeitem = NULL;
TVHITTESTINFO ti;
memset(&ti, 0, sizeof(ti));
if (pt.x != -1 && pt.y != -1)
{
ti.pt = pt;
ScreenToClient(list, &ti.pt);
uSendMessage(list, TVM_HITTEST, 0, (long)&ti);
if (ti.hItem && (ti.flags & TVHT_ONITEM))
{
//FIX THIS AND AUTOSEND
//TreeView_Select(list, ti.hItem, TVGN_DROPHILITE);
//uSendMessage(list,TVM_SELECTITEM,TVGN_DROPHILITE,(long)ti.hItem);
treeitem = ti.hItem;
}
}
else
{
treeitem = TreeView_GetSelection(list);
RECT rc;
if (treeitem && TreeView_GetItemRect(wnd_tv, treeitem, &rc, TRUE))
{
MapWindowPoints(wnd_tv, HWND_DESKTOP, (LPPOINT)&rc, 2);
pt.x = rc.left;
pt.y = rc.top + (rc.bottom - rc.top) / 2;
}
else
{
GetMessagePos(&pt);
}
}
TreeView_Select(list, treeitem, TVGN_DROPHILITE);
HMENU menu_view = CreatePopupMenu();
unsigned n, m = cfg_view_list.get_count();
string8_fastalloc temp;
temp.prealloc(32);
uAppendMenu(menu_view, MF_STRING | (!stricmp_utf8(directory_structure_view_name, view) ? MF_CHECKED : 0), ID_VIEW_BASE + 0, directory_structure_view_name);
list_t<string_simple, pfc::alloc_fast> views;
views.add_item(string_simple(directory_structure_view_name));
for (n = 0; n<m; n++)
{
temp = cfg_view_list.get_name(n);
string_simple item(temp.get_ptr());
if (item)
{
uAppendMenu(menu_view, MF_STRING | (!stricmp_utf8(temp, view) ? MF_CHECKED : 0), ID_VIEW_BASE + views.add_item(item), temp);
}
}
IDM_MANAGER_BASE = ID_VIEW_BASE + views.get_count();
uAppendMenu(menu, MF_STRING | MF_POPUP, (UINT)menu_view, "View");
if (!m_populated && !cfg_populate)
uAppendMenu(menu, MF_STRING, ID_REFRESH, "Populate");
uAppendMenu(menu, MF_STRING | (m_filter ? MF_CHECKED : 0), ID_FILT, "Filter");
uAppendMenu(menu, MF_STRING, ID_CONF, "Settings");
bool show_shortcuts = standard_config_objects::query_show_keyboard_shortcuts_in_menus();
node * p_node = NULL;
TVITEMEX tvi;
memset(&tvi, 0, sizeof(tvi));
tvi.hItem = treeitem;
tvi.mask = TVIF_HANDLE | TVIF_PARAM;
TreeView_GetItem(list, &tvi);
p_node = (node*)tvi.lParam;
if (treeitem && p_node)
{
uAppendMenu(menu, MF_SEPARATOR, 0, "");
uAppendMenu(menu, MF_STRING, ID_SEND, (show_shortcuts ? "&Send to playlist\tEnter" : "&Send to playlist"));
uAppendMenu(menu, MF_STRING, ID_ADD, show_shortcuts ? "&Add to playlist\tShift+Enter" : "&Add to playlist");
uAppendMenu(menu, MF_STRING, ID_NEW, show_shortcuts ? "Send to &new playlist\tCtrl+Enter" : "Send to &new playlist");
uAppendMenu(menu, MF_STRING, ID_AUTOSEND, "Send to &autosend playlist");
if (!static_api_ptr_t<core_version_info_v2>()->test_version(0, 9, 6, 0))
{
uAppendMenu(menu, MF_STRING, ID_REMOVE, "&Remove from library");
uAppendMenu(menu, MF_STRING, ID_REMOVEDEAD, "Remove &dead entries (slow)");
}
uAppendMenu(menu, MF_SEPARATOR, 0, "");
contextmenu_manager::g_create(p_menu_manager);
p_node->sort_entries();
if (p_menu_manager.is_valid())
{
p_menu_manager->init_context(p_node->get_entries(), 0);
p_menu_manager->win32_build_menu(menu, IDM_MANAGER_BASE, -1);
menu_helpers::win32_auto_mnemonics(menu);
}
}
int cmd = TrackPopupMenu(menu, TPM_RIGHTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD, pt.x, pt.y, 0, get_wnd(), 0);
DestroyMenu(menu);
TreeView_Select(list, NULL, TVGN_DROPHILITE);
if (cmd)
{
if (p_menu_manager.is_valid() && (unsigned)cmd >= IDM_MANAGER_BASE)
{
p_menu_manager->execute_by_id(cmd - IDM_MANAGER_BASE);
}
else if (cmd >= ID_VIEW_BASE)
{
unsigned n = cmd - ID_VIEW_BASE;
if (n<views.get_count())
{
view = views[n].get_ptr();
refresh_tree();
}
}
else if (cmd<ID_VIEW_BASE)
{
unsigned cmd2 = 0;
switch (cmd)
{
case ID_NEW:
do_playlist(p_node, true, true);
break;
case ID_SEND:
do_playlist(p_node, true);
break;
case ID_ADD:
do_playlist(p_node, false);
break;
case ID_AUTOSEND:
do_autosend_playlist(p_node, view, true);
break;
case ID_CONF:
{
static_api_ptr_t<ui_control>()->show_preferences(g_guid_preferences_album_list_panel);
}
break;
case ID_FILT:
{
m_filter = !m_filter;
create_or_destroy_filter();
}
break;
case ID_REMOVE:
p_node->remove_from_db();
break;
case ID_REMOVEDEAD:
p_node->remove_dead();
break;
case ID_REFRESH:
if (!m_populated && !cfg_populate)
refresh_tree();
break;
}
if (cmd2) uSendMessage(get_wnd(), WM_COMMAND, cmd2, 0);
}
}
p_menu_manager.release();
/* if (treeitem_context && (treeitem_context != treeitem) && cfg_autosend)
TreeView_SelectItem(wnd_tv,treeitem);*/
}
return 0;
case WM_NOTIFY:
{
LPNMHDR hdr = (LPNMHDR)lp;
switch (hdr->idFrom)
{
case IDC_TREE:
{
if (hdr->code == TVN_ITEMEXPANDING)
{
LPNMTREEVIEW param = (LPNMTREEVIEW)hdr;
if (cfg_picmixer && (param->action == TVE_EXPAND))
{
TreeView_CollapseOtherNodes(param->hdr.hwndFrom, param->itemNew.hItem);
}
}
else if (hdr->code == TVN_SELCHANGED)
{
LPNMTREEVIEW param = (LPNMTREEVIEW)hdr;
p_selection = (node*)param->itemNew.lParam;
if ((param->action == TVC_BYMOUSE || param->action == TVC_BYKEYBOARD))
{
if (cfg_autosend)
do_autosend_playlist(p_selection, view);
}
if (m_selection_holder.is_valid())
{
m_selection_holder->set_selection(p_selection.is_valid() ? p_selection->get_entries() : metadb_handle_list());
}
#if 0
if (cfg_picmixer)
{
HTREEITEM ti_parent_old = TreeView_GetParent(param->hdr.hwndFrom, param->itemOld.hItem);
HTREEITEM ti_parent_new = TreeView_GetParent(param->hdr.hwndFrom, param->itemNew.hItem);
if (/*ti_parent_old != param->itemNew.hItem && */!TreeView_IsChild(param->hdr.hwndFrom, param->itemNew.hItem, param->itemOld.hItem))
{
HTREEITEM ti = //TreeView_GetLevel(param->hdr.hwndFrom, param->itemNew.hItem) < TreeView_GetLevel(param->hdr.hwndFrom, param->itemOld.hItem) ?
TreeView_GetCommonParentChild(param->hdr.hwndFrom, param->itemOld.hItem, param->itemNew.hItem)
//: param->itemOld.hItem
;
if (ti && ti != TVI_ROOT) TreeView_Expand(param->hdr.hwndFrom, ti, TVE_COLLAPSE);
}
if (ti_parent_new)
{
HTREEITEM child = TreeView_GetChild(param->hdr.hwndFrom, ti_parent_new);
while (child)
{
if (child != param->itemNew.hItem)
{
}
}
}
}
#endif
}
}
break;
}
}
break;
case WM_DESTROY:
static_api_ptr_t<library_manager_v3>()->unregister_callback(this);
modeless_dialog_manager::g_remove(wnd);
destroy_tree();
destroy_filter();
m_selection_holder.release();
m_root.release();
p_selection.release();
if (initialised)
{
list_wnd.remove_item(this);
if (list_wnd.get_count() == 0)
{
DeleteFont(g_font);
g_font = 0;
}
initialised = false;
}
break;
}
return DefWindowProc(wnd, msg, wp, lp);
}
static PyObject *
init_filters(const _PyCoreConfig *config)
{
int dev_mode = config->dev_mode;
Py_ssize_t count = 2;
if (dev_mode) {
count++;
}
#ifndef Py_DEBUG
if (!dev_mode) {
count += 3;
}
#endif
PyObject *filters = PyList_New(count);
if (filters == NULL)
return NULL;
size_t pos = 0; /* Post-incremented in each use. */
#ifndef Py_DEBUG
if (!dev_mode) {
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_DeprecationWarning, &PyId_ignore));
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_PendingDeprecationWarning, &PyId_ignore));
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_ImportWarning, &PyId_ignore));
}
#endif
_Py_Identifier *bytes_action;
if (Py_BytesWarningFlag > 1)
bytes_action = &PyId_error;
else if (Py_BytesWarningFlag)
bytes_action = &PyId_default;
else
bytes_action = &PyId_ignore;
PyList_SET_ITEM(filters, pos++, create_filter(PyExc_BytesWarning,
bytes_action));
_Py_Identifier *resource_action;
/* resource usage warnings are enabled by default in pydebug mode */
#ifdef Py_DEBUG
resource_action = &PyId_default;
#else
resource_action = (dev_mode ? &PyId_default: &PyId_ignore);
#endif
PyList_SET_ITEM(filters, pos++, create_filter(PyExc_ResourceWarning,
resource_action));
if (dev_mode) {
PyList_SET_ITEM(filters, pos++,
create_filter(PyExc_Warning, &PyId_default));
}
for (size_t x = 0; x < pos; x++) {
if (PyList_GET_ITEM(filters, x) == NULL) {
Py_DECREF(filters);
return NULL;
}
}
return filters;
}
void build_network (void)
{
NUM_ISOLATE_NEURON_LAYERS = 12;
NUM_INPUTS = 2;
NUM_OUTPUTS = 6;
NUM_FILTERS = 2;
srand (5);
memset((void *) &(nl_ita_lp_f), 0, sizeof(NEURON_LAYER));
nl_ita_lp_f.name = "nl_ita_lp_f";
memset((void *) &(nl_prediction), 0, sizeof(NEURON_LAYER));
nl_prediction.name = "nl_prediction";
memset((void *) &(nl_test), 0, sizeof(NEURON_LAYER));
nl_test.name = "nl_test";
memset((void *) &(nl_result), 0, sizeof(NEURON_LAYER));
nl_result.name = "nl_result";
memset((void *) &(nl_ita2_lp_f), 0, sizeof(NEURON_LAYER));
nl_ita2_lp_f.name = "nl_ita2_lp_f";
memset((void *) &(nl_prediction2), 0, sizeof(NEURON_LAYER));
nl_prediction2.name = "nl_prediction2";
memset((void *) &(ita), 0, sizeof(INPUT_DESC));
ita.name = "ita";
memset((void *) &(ita2), 0, sizeof(INPUT_DESC));
ita2.name = "ita2";
memset((void *) &(out_ita_lp_f), 0, sizeof(OUTPUT_DESC));
out_ita_lp_f.name = "out_ita_lp_f";
memset((void *) &(out_prediction), 0, sizeof(OUTPUT_DESC));
out_prediction.name = "out_prediction";
memset((void *) &(out_test), 0, sizeof(OUTPUT_DESC));
out_test.name = "out_test";
memset((void *) &(out_result), 0, sizeof(OUTPUT_DESC));
out_result.name = "out_result";
memset((void *) &(out_ita2_lp_f), 0, sizeof(OUTPUT_DESC));
out_ita2_lp_f.name = "out_ita2_lp_f";
memset((void *) &(out_prediction2), 0, sizeof(OUTPUT_DESC));
out_prediction2.name = "out_prediction2";
__line = 2;
NEURON_MEMORY_SIZE = 10000;
__line = 4;
TYPE_SHOW = SHOW_FRAME;
__line = 5;
TYPE_MOVING_FRAME = STOP;
__line = 8;
//;
__line = 9;
//;
__line = 11;
//;
__line = 12;
//;
__line = 14;
//;
__line = 16;
//;
__line = 17;
//;
__line = 18;
//;
__line = 19;
//;
__line = 20;
//;
__line = 21;
//;
__line = 22;
//;
__line = 25;
create_neuron_layer (&nl_ita_lp_f, NULL, NOT_SPECIFIED, GREYSCALE_FLOAT, INPUT_WIDTH,INPUT_HEIGHT,DISTRIBUTED_MEMORY, NEURON_MEMORY_SIZE);
__line = 26;
create_neuron_layer (&nl_prediction, &minchinton, GREYSCALE_FLOAT, GREYSCALE_FLOAT, OUT_WIDTH,OUT_HEIGHT,DISTRIBUTED_MEMORY, NEURON_MEMORY_SIZE);
__line = 27;
create_neuron_layer (&nl_test, &minchinton, GREYSCALE_FLOAT, GREYSCALE_FLOAT, OUT_WIDTH,OUT_HEIGHT,DISTRIBUTED_MEMORY, NEURON_MEMORY_SIZE);
__line = 28;
create_neuron_layer (&nl_result, &minchinton, GREYSCALE_FLOAT, GREYSCALE_FLOAT, OUT_WIDTH,OUT_HEIGHT,DISTRIBUTED_MEMORY, NEURON_MEMORY_SIZE);
__line = 30;
create_neuron_layer (&nl_ita2_lp_f, NULL, NOT_SPECIFIED, GREYSCALE_FLOAT, INPUT_WIDTH,INPUT_HEIGHT,DISTRIBUTED_MEMORY, NEURON_MEMORY_SIZE);
__line = 31;
create_neuron_layer (&nl_prediction2, &minchinton, GREYSCALE_FLOAT, GREYSCALE_FLOAT, OUT_WIDTH,OUT_HEIGHT,DISTRIBUTED_MEMORY, NEURON_MEMORY_SIZE);
__line = 34;
create_output (&out_ita_lp_f, INPUT_WIDTH,INPUT_HEIGHT, NULL, 0);
__line = 35;
create_output (&out_prediction, OUT_WIDTH,OUT_HEIGHT, output_handler, " ");
__line = 36;
create_output (&out_test, OUT_WIDTH,OUT_HEIGHT, NULL, 0);
__line = 37;
create_output (&out_result, OUT_WIDTH,OUT_HEIGHT, NULL, 0);
__line = 39;
create_output (&out_ita2_lp_f, INPUT_WIDTH,INPUT_HEIGHT, NULL, 0);
__line = 40;
create_output (&out_prediction2, OUT_WIDTH,OUT_HEIGHT, output_handler, " ");
__line = 43;
create_input (&ita, INPUT_WIDTH,INPUT_HEIGHT, GREYSCALE_FLOAT, 0, REGULAR_PYRAMID, input_generator, input_controler, " ", " ");
__line = 45;
create_input (&ita2, INPUT_WIDTH,INPUT_HEIGHT, GREYSCALE_FLOAT, 0, REGULAR_PYRAMID, input_generator, input_controler, " ", " ");
__line = 49;
create_filter (copy_nl_filter, &nl_ita_lp_f, 1, ita.neuron_layer, "");
__line = 51;
create_filter (copy_nl_filter, &nl_ita2_lp_f, 1, ita2.neuron_layer, "");
__line = 54;
output_connect (&nl_ita_lp_f, &out_ita_lp_f);
__line = 55;
output_connect (&nl_prediction, &out_prediction);
__line = 56;
output_connect (&nl_test, &out_test);
__line = 57;
output_connect (&nl_result, &out_result);
__line = 59;
output_connect (&nl_ita2_lp_f, &out_ita2_lp_f);
__line = 60;
output_connect (&nl_prediction2, &out_prediction2);
__line = 63;
associate_neurons (&nl_prediction, &nl_prediction);
__line = 65;
associate_neurons (&nl_prediction2, &nl_prediction2);
__line = 68;
connect_neurons (GAU2, &nl_ita_lp_f, &nl_prediction, SYNAPSES, 0.0, 9.32433, 0.0, -1,-1,-1,-1, -1,-1,-1,-1, DIFFERENT_INTERCONNECTION_PATTERN);
__line = 74;
connect_neurons (GAU2, &nl_ita2_lp_f, &nl_prediction2, SYNAPSES, 0.0, 9.32433, 0.0, -1,-1,-1,-1, -1,-1,-1,-1, DIFFERENT_INTERCONNECTION_PATTERN);
__line = 77;
create_interpreter_user_function (INT_TYPE, GetRandomReturns, "GetRandomReturns", "%d");
;
__line = 78;
create_interpreter_user_function (INT_TYPE, ShowStatistics, "ShowStatistics", "%d");
;
__line = 79;
create_interpreter_user_function (INT_TYPE, ResetStatistics, "ResetStatistics", "%d");
;
__line = 80;
create_interpreter_user_function (INT_TYPE, SetNetworkStatus, "SetNetworkStatus", "%d");
;
__line = 81;
create_interpreter_user_function (INT_TYPE, LoadReturns, "LoadReturns", "%s");
;
__line = 82;
create_interpreter_user_function (INT_TYPE, LoadDayFileName, "LoadDayFileName", "%s");
;
__line = 83;
create_interpreter_user_function (INT_TYPE, LoadDay, "LoadDay", "%d");
;
__line = 84;
create_interpreter_user_function (INT_TYPE, ShowStatisticsExp, "ShowStatisticsExp", "%d");
;
__line = 85;
create_interpreter_user_function (INT_TYPE, MeanStatisticsExp, "MeanStatisticsExp", "%d");
;
__line = 86;
create_interpreter_user_function (INT_TYPE, SetLongShort, "SetLongShort", "%d");
;
map_layers2id ();
count_num_neurons ();
initialise_memory ();
create_io_windows ();
}
void UI_BDF2EDFwindow::StartConversion()
{
int i, j, k,
datrecs,
new_edfsignals,
datarecords,
len,
progress_steps;
char *readbuf,
scratchpad[256];
union {
unsigned int one;
signed int one_signed;
unsigned short two[2];
signed short two_signed[2];
unsigned char four[4];
} var;
union {
signed short one_short;
unsigned char two_bytes[2];
} var2;
pushButton3->setEnabled(false);
pushButton4->setEnabled(false);
pushButton5->setEnabled(false);
if(edfhdr==NULL)
{
return;
}
if(edfhdr->edfsignals>MAXSIGNALS)
{
return;
}
new_edfsignals = 0;
for(i=0; i<edfhdr->edfsignals; i++)
{
if(!edfhdr->edfparam[i].annotation)
{
if(((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->checkState()==Qt::Checked)
{
signalslist[new_edfsignals] = i;
annotlist[new_edfsignals] = 0;
filterlist[new_edfsignals] = create_filter(0,
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->value(),
1.0 / (edfhdr->data_record_duration / edfhdr->edfparam[i].smp_per_record));
dividerlist[new_edfsignals] = ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 2)))->value();
new_edfsignals++;
}
}
else
{
signalslist[new_edfsignals] = i;
annotlist[new_edfsignals] = 1;
filterlist[new_edfsignals] = create_filter(0, 0.01,
1.0 / (edfhdr->data_record_duration / edfhdr->edfparam[i].smp_per_record));
dividerlist[new_edfsignals] = 1.0;
new_edfsignals++;
}
}
datarecords = edfhdr->datarecords;
QProgressDialog progress("Converting...", "Abort", 0, datarecords, myobjectDialog);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress.reset();
if(!new_edfsignals)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "You must select at least one signal.");
messagewindow.exec();
goto END_1;
}
readbuf = (char *)malloc(edfhdr->recordsize);
if(readbuf==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error, (readbuf).");
messagewindow.exec();
goto END_2;
}
/////////////////////////// write header ////////////////////////////////////////
outputpath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(outputpath, recent_savedir);
strcat(outputpath, "/");
}
len = strlen(outputpath);
get_filename_from_path(outputpath + len, inputpath, MAX_PATH_LENGTH - len);
remove_extension_from_filename(outputpath);
strcat(outputpath, ".edf");
strcpy(outputpath, QFileDialog::getSaveFileName(0, "Select outputfile", QString::fromLocal8Bit(outputpath), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(outputpath, ""))
{
goto END_2;
}
get_directory_from_path(recent_savedir, outputpath, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(outputpath))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, selected file is in use.");
messagewindow.exec();
goto END_2;
}
outputfile = fopeno(outputpath, "wb");
if(outputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open outputfile for writing.");
messagewindow.exec();
goto END_2;
}
fprintf(outputfile, "0 ");
fseeko(inputfile, 8LL, SEEK_SET);
if(fread(scratchpad, 176, 1, inputfile)!=1)
{
showpopupmessage("Error", "Read error (1).");
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Read error (1).");
messagewindow.exec();
goto END_3;
}
if(fwrite(scratchpad, 176, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Write error (1).");
messagewindow.exec();
goto END_3;
}
fprintf(outputfile, "%-8i", new_edfsignals * 256 + 256);
if(edfhdr->bdfplus)
{
if(edfhdr->discontinuous)
{
fprintf(outputfile, "EDF+D");
}
else
{
fprintf(outputfile, "EDF+C");
}
for(i=0; i<39; i++)
{
fputc(' ', outputfile);
}
}
else
{
for(i=0; i<44; i++)
{
fputc(' ', outputfile);
}
}
fprintf(outputfile, "%-8i", datarecords);
snprintf(scratchpad, 256, "%f", edfhdr->data_record_duration);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
fprintf(outputfile, "%-4i", new_edfsignals);
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
fprintf(outputfile, "EDF Annotations ");
}
else
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].label);
}
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].transducer);
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].physdimension);
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
fprintf(outputfile, "-1 ");
}
else
{
snprintf(scratchpad, 256, "%f", edfhdr->edfparam[signalslist[i]].bitvalue * -32768.0 * dividerlist[i]);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
}
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
fprintf(outputfile, "1 ");
}
else
{
snprintf(scratchpad, 256, "%f", edfhdr->edfparam[signalslist[i]].bitvalue * 32767.0 * dividerlist[i]);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
}
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "-32768 ");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "32767 ");
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
for(j=0; j<80; j++)
{
fputc(' ', outputfile);
}
}
else
{
snprintf(scratchpad, 256, "HP:%f", ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(signalslist[i], 1)))->value());
remove_trailing_zeros(scratchpad);
strcat(scratchpad, "Hz ");
strcat(scratchpad, edfhdr->edfparam[signalslist[i]].prefilter);
for(j=strlen(scratchpad); j<200; j++)
{
scratchpad[j] = ' ';
}
scratchpad[200] = 0;
for(j=0; j<80; j++)
{
if(!strncmp(scratchpad + j, "No filtering", 12))
{
for(k=j; k<(j+12); k++)
{
scratchpad[k] = ' ';
}
}
}
for(j=0; j<80; j++)
{
if(!strncmp(scratchpad + j, "None", 4))
{
for(k=j; k<(j+4); k++)
{
scratchpad[k] = ' ';
}
}
}
for(j=0; j<80; j++)
{
if(!strncmp(scratchpad + j, "HP: DC;", 7))
{
for(k=j; k<(j+7); k++)
{
scratchpad[k] = ' ';
}
}
}
scratchpad[80] = 0;
fprintf(outputfile, "%s", scratchpad);
}
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
if(edfhdr->edfparam[signalslist[i]].smp_per_record % 2)
{
fprintf(outputfile, "%-8i", ((edfhdr->edfparam[signalslist[i]].smp_per_record * 15) / 10) + 1);
}
else
{
fprintf(outputfile, "%-8i", (edfhdr->edfparam[signalslist[i]].smp_per_record * 15) / 10);
}
}
else
{
fprintf(outputfile, "%-8i", edfhdr->edfparam[signalslist[i]].smp_per_record);
}
}
for(i=0; i<(new_edfsignals * 32); i++)
{
fputc(' ', outputfile);
}
///////////////////////////// start conversion //////////////////////////////////////
progress_steps = datarecords / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
fseeko(inputfile, (long long)(edfhdr->hdrsize), SEEK_SET);
for(datrecs=0; datrecs<datarecords; datrecs++)
{
if(!(datrecs%progress_steps))
{
progress.setValue(datrecs);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
goto END_3;
}
}
if(fread(readbuf, edfhdr->recordsize, 1, inputfile) != 1)
{
progress.reset();
showpopupmessage("Error", "Read error (2).");
goto END_3;
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
if(fwrite(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset, edfhdr->edfparam[signalslist[i]].smp_per_record * 3, 1, outputfile)!=1)
{
progress.reset();
showpopupmessage("Error", "Write error (2).");
goto END_3;
}
if(edfhdr->edfparam[signalslist[i]].smp_per_record % 2)
{
if(fputc(0, outputfile)==EOF)
{
progress.reset();
showpopupmessage("Error", "Write error (3).");
goto END_3;
}
}
}
else
{
for(j=0; j<edfhdr->edfparam[signalslist[i]].smp_per_record; j++)
{
var.two[0] = *((unsigned short *)(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset + (j * 3)));
var.four[2] = *((unsigned char *)(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset + (j * 3) + 2));
if(var.four[2]&0x80)
{
var.four[3] = 0xff;
}
else
{
var.four[3] = 0x00;
}
var.one_signed += edfhdr->edfparam[signalslist[i]].offset;
var.one_signed = first_order_filter(var.one_signed, filterlist[i]);
var.one_signed /= dividerlist[i];
if(var.one_signed>32767) var.one_signed = 32767;
if(var.one_signed<-32768) var.one_signed = -32768;
var2.one_short = var.one_signed;
fputc(var2.two_bytes[0], outputfile);
if(fputc(var2.two_bytes[1], outputfile)==EOF)
{
progress.reset();
showpopupmessage("Error", "Write error (4).");
goto END_3;
}
}
}
}
}
progress.reset();
showpopupmessage("Ready", "Done.");
END_3:
fclose(outputfile);
outputfile = NULL;
END_2:
free(readbuf);
END_1:
for(i=0; i<new_edfsignals; i++)
{
free(filterlist[i]);
}
fclose(inputfile);
inputfile = NULL;
inputpath[0] = 0;
outputpath[0] = 0;
free_edfheader();
label1->setText("");
SignalsTablewidget->setRowCount(0);
}
void
run_test(enum test_type t_type, uint8_t use_hashes)
{
uint64_t i;
uint64_t is_member_count;
uint64_t rnd_nbr;
char *type;
uint64_t set_bits;
struct timeval tval_before, tval_after, tval_result;
/* insertion */
create_filter(filter_size, use_hashes);
gettimeofday(&tval_before, NULL);
switch (t_type) {
case EVEN_UNEVEN:
type = "un/even";
for (i = 1; i < insert_size << 1; i += 2) {
insert_key((char *)&i, 8);
}
break;
case RANDOM:
type = "random";
for (i = 0; i < insert_size; i++) {
rnd_nbr = arc4random();
rnd_nbr = rnd_nbr << 32;
rnd_nbr = rnd_nbr | arc4random();
insert_key((char *)&rnd_nbr, 8);
}
break;
case COUNTING:
type = "counting";
for (i = 0; i < insert_size; i++) {
insert_key((char *)&i, 8);
}
break;
default:
/* not reached */
type = "";
break;
}
gettimeofday(&tval_after, NULL);
timersub(&tval_after, &tval_before, &tval_result);
/* testing */
is_member_count = 0;
switch (t_type) {
case EVEN_UNEVEN:
for (i = 0; i < insert_size << 1; i += 2) {
if (is_member((char *)&i, 8)) {
is_member_count++;
}
}
break;
case RANDOM:
for (i = 0; i < insert_size; i++) {
rnd_nbr = arc4random();
rnd_nbr = rnd_nbr << 32;
rnd_nbr = rnd_nbr | arc4random();
if (is_member((char *)&rnd_nbr, 8)) {
is_member_count++;
}
}
break;
case COUNTING:
for (i = insert_size; i < insert_size << 1; i++) {
if (is_member((char *)&i, 8)) {
is_member_count++;
}
}
break;
default:
/* not reached */
break;
}
set_bits = estimate_cardinality();
/* print info */
printf("%-8s: ins time: %2ld.%-6ld false pos: %6.2f%% (%10lu) fill factor: %6.2f%% (%10lu) err rate: %6.2f%% (%10lu)\n",
type,
(long int)tval_result.tv_sec,
(long int)tval_result.tv_usec,
(double)is_member_count / (double)insert_size * 100.0,
is_member_count,
(double)set_bits / (double)filter_size * 100.0,
set_bits,
(double)(insert_size * K - set_bits) / (double)(insert_size * K) * 100.0,
insert_size * K - set_bits);
}
int main(int argc,char *argv [])
{
CORBA::ORB_ptr orb_ptr;
try
{
/************************************************************************/
/* INICIALIZAMOS LA PARTE DEL ORB */
/************************************************************************/
int alt_argc = 0;
char ** alt_argv;
const char * orb_id="Test_TIDNotification";
orb_ptr=CORBA::ORB_init(argc, argv, orb_id);
if (!orb_ptr)
{
cerr<<"El ORB es null"<<endl;
return -1;
}
CORBA::Object_ptr delegado_POA;
PortableServer::POA_ptr rootPOA;
try
{
delegado_POA = orb_ptr->resolve_initial_references("RootPOA");
}
catch ( CORBA::ORB::InvalidName ex )
{
ex._name();
return -1;
}
rootPOA = PortableServer::_POAHelper::narrow( delegado_POA,true );
PortableServer::POAManager_var poa_manager = rootPOA->the_POAManager();
CORBA::PolicyList_var policies = NULL;
policies = new CORBA::PolicyList(2);
policies->length(2);
// Valores cambiados
(*policies)[0] = rootPOA->create_lifespan_policy
( PortableServer::PERSISTENT );
(*policies)[1] = rootPOA->create_id_assignment_policy
( PortableServer::USER_ID );
PortableServer::POA_var consumerPOA = rootPOA->create_POA("consumerPOA", poa_manager, *policies );
/***********************************************************************/
/* OBTENEMOS LA FACTORIA DEL CANAL DE EVENTOS Y CREAMOS EL CANAL */
/**********************************************************************/
CORBA::Object_ptr delegado_event_channel_factory;
delegado_event_channel_factory=orb_ptr->string_to_object(argv[1]);
CosNotifyChannelAdmin::EventChannelFactory_var factory;
factory = CosNotifyChannelAdmin::EventChannelFactory::_narrow(delegado_event_channel_factory);
if (CORBA::is_nil(factory)) {
cerr << "[server] ERROR: factoria nula " << endl;
return -1;
}
CosNotifyChannelAdmin::EventChannel_var channel;
//CosNotifyChannelAdmin::EventChannel_var channelv[10];
CosNotification::QoSProperties initial_qos;
CosNotification::AdminProperties initial_admin;
CosNotifyChannelAdmin::ChannelID id;
//CosNotifyChannelAdmin::ChannelID idv[10];
// // Politicas Soportadas:
// initial_qos.length(9);
// initial_qos[0].name = CORBA::string_dup("OrderPolicy");
// initial_qos[0].value <<= CosNotification::FifoOrder; // Any Fifo Priority Deadline
// initial_qos[1].name = CORBA::string_dup("EventReliability");
// initial_qos[1].value <<= CosNotification::BestEffort; // Persistent
// initial_qos[2].name = CORBA::string_dup("ConnectionReliability");
// initial_qos[2].value <<= CosNotification::BestEffort; // Persistent
// initial_qos[3].name = CORBA::string_dup("Priority");
// initial_qos[3].value <<= CosNotification::HighestPriority; // Highest, Default
// initial_qos[4].name = CORBA::string_dup("StartTime");
// initial_qos[4].value <<= *(new TimeBase::UtcT(
// TIDorb::core::util::Time::currentTimeMillis(),
// 0,0,0));
// initial_qos[5].name = CORBA::string_dup("StopTime");
// initial_qos[5].value <<= *(new TimeBase::UtcT(
// TIDorb::core::util::Time::currentTimeMillis(),
// 0,0,0));
// initial_qos[6].name = CORBA::string_dup("Timeout");
// initial_qos[6].value <<= (TimeBase::TimeT)TIDorb::core::util::Time::currentTimeMillis();
// initial_qos[7].name = CORBA::string_dup("StartTimeSupported");
// initial_qos[7].value <<= (CORBA::Boolean) 0;
// initial_qos[8].name = CORBA::string_dup("StopTimeSupported");
// initial_qos[8].value <<= (CORBA::Boolean) 1;
//
// Politicas de QoS no soportadas
//
// initial_qos[0].name = CORBA::string_dup("DiscardPolicy");
// initial_qos[0].value <<= CosNotification::AnyOrder; // Any Fifo Priority Deadline
// initial_qos[7].name = CORBA::string_dup("MaximumBatchSize");
// initial_qos[7].value <<= (CORBA::Long) 20;
// initial_qos[0].name = CORBA::string_dup("PacingInterval");
// initial_qos[0].value <<= (TimeBase::TimeT)TIDorb::core::util::Time::currentTimeMillis();
// initial_qos[9].name = CORBA::string_dup("MaxEventsPerConsumer");
// initial_qos[9].value <<= (CORBA::Long) 20;
try {
// Crear el canal
channel = factory->get_event_channel(0);
// for(int i=0; i < 10; i++){
// channelv[i] = factory->create_channel(initial_qos, initial_admin, idv[i]);
// }
} catch (CosNotifyChannelAdmin::ChannelNotFound &ex) {
cerr << "[server_consumer] CosNotifyChannelAdmin::ChannelNotFound: " << ex._name();
return -1;
}
/**************************************************************************/
/* OBTENEMOS EL CONSUMERADMIN POR DEFECTO */
/**************************************************************************/
CosNotifyChannelAdmin::ConsumerAdmin_ptr consumerAdmin;
consumerAdmin = channel->default_consumer_admin();
//Metemos los filtros en el consumer admin
CosNotifyFilter::Filter* filter_II = create_filter(channel,"GSyC","test","$domain_name != 'GSyC'");
//consumerAdmin->add_filter(filter_II);
//CosNotifyFilter::Filter* filter_III = create_filter(channel,"GSyC","test","$.remainder_of_boy.campo_uno != 1");
//consumerAdmin->add_filter(filter_III);
/**************************************************************************/
/* OBTENEMOS EL PROXYSUPPLIER APARTIR DEL CONSUMERADMIN */
/**************************************************************************/
//TODO_MORFEO: add new filters
CosNotifyChannelAdmin::ProxySupplier_ptr proxySupplier;
CosNotifyChannelAdmin::ProxyID proxySupplierID = 1;
proxySupplier =
consumerAdmin->obtain_notification_push_supplier(CosNotifyChannelAdmin::ANY_EVENT,
proxySupplierID);
/**************************************************************************/
/* OBTENEMOS EL PROXYPUSHSUPPLIER APARTIR DEL CONSUMERADMIN */
/**************************************************************************/
CosNotifyChannelAdmin::StructuredProxyPushSupplier_ptr proxyPushSupplier;
proxyPushSupplier = CosNotifyChannelAdmin::StructuredProxyPushSupplier::_narrow(proxySupplier);
/**************************************************************************/
/* INSTANCIAMOS LOS PROXYS Y LOS ACTIVAMOS EN EL POA */
/**************************************************************************/
my_push_consumer * my_consumer = new my_push_consumer(orb_ptr,proxyPushSupplier);
PortableServer::ObjectId_ptr consumer_objectID = PortableServer::string_to_ObjectId("My_Consumer:1.0");
consumerPOA->activate_object_with_id(*consumer_objectID,my_consumer);
poa_manager->activate();
CORBA::Object_ptr obj_consumer = consumerPOA->id_to_reference(*consumer_objectID);
CosNotifyComm::StructuredPushConsumer_ptr my_pushConsumer = CosNotifyComm::StructuredPushConsumer::_narrow(obj_consumer);
/***********************************************************************/
/* CONECTAMOS EL PUSHSUPPLIER Y EL PUSHCONSUMER */
/***********************************************************************/
proxyPushSupplier->connect_structured_push_consumer(my_pushConsumer);
orb_ptr->run();
}
catch (CORBA::Exception & e)
{
cerr<<"[Test_Filter] unknown error"<< typeid(e).name() << e._name();
return -1;
}
}
/*******************************************************************************
* d_filter_t create_first_order_low_pass(float dt, float time_constant)
*
* Returns a configured and ready to use d_filter_t_t struct with a first order
* low pass transfer function. dt is in units of seconds and time_constant is
* the number of seconds it takes to rise to 63.4% of a steady-state input.
*******************************************************************************/
d_filter_t create_first_order_low_pass(float dt, float time_constant){
const float lp_const = dt/time_constant;
float numerator[] = {lp_const, 0};
float denominator[] = {1, lp_const-1};
return create_filter(1,dt,numerator,denominator);
}
static void *eq_init(const struct dspfilter_info *info,
const struct dspfilter_config *config, void *userdata)
{
float *frequencies, *gain;
unsigned num_freq, num_gain, i, size;
int size_log2;
float beta;
struct eq_gain *gains = NULL;
char *filter_path = NULL;
const float default_freq[] = { 0.0f, info->input_rate };
const float default_gain[] = { 0.0f, 0.0f };
struct eq_data *eq = (struct eq_data*)calloc(1, sizeof(*eq));
if (!eq)
return NULL;
config->get_float(userdata, "window_beta", &beta, 4.0f);
config->get_int(userdata, "block_size_log2", &size_log2, 8);
size = 1 << size_log2;
config->get_float_array(userdata, "frequencies", &frequencies, &num_freq, default_freq, 2);
config->get_float_array(userdata, "gains", &gain, &num_gain, default_gain, 2);
if (!config->get_string(userdata, "impulse_response_output", &filter_path, ""))
{
config->free(filter_path);
filter_path = NULL;
}
num_gain = num_freq = MIN(num_gain, num_freq);
gains = (struct eq_gain*)calloc(num_gain, sizeof(*gains));
if (!gains)
goto error;
for (i = 0; i < num_gain; i++)
{
gains[i].freq = frequencies[i] / (0.5f * info->input_rate);
gains[i].gain = pow(10.0, gain[i] / 20.0);
}
config->free(frequencies);
config->free(gain);
eq->block_size = size;
eq->save = (float*)calloc( size, 2 * sizeof(*eq->save));
eq->block = (float*)calloc(2 * size, 2 * sizeof(*eq->block));
eq->fftblock = (fft_complex_t*)calloc(2 * size, sizeof(*eq->fftblock));
eq->filter = (fft_complex_t*)calloc(2 * size, sizeof(*eq->filter));
/* Use an FFT which is twice the block size with zero-padding
* to make circular convolution => proper convolution.
*/
eq->fft = fft_new(size_log2 + 1);
if (!eq->fft || !eq->fftblock || !eq->save || !eq->block || !eq->filter)
goto error;
create_filter(eq, size_log2, gains, num_gain, beta, filter_path);
config->free(filter_path);
filter_path = NULL;
free(gains);
return eq;
error:
free(gains);
eq_free(eq);
return NULL;
}
static int
search_one_berval(Slapi_DN *baseDN, const char *attrName,
const struct berval *value, const char *requiredObjectClass,
Slapi_DN *target)
{
int result;
char *filter;
Slapi_PBlock *spb;
result = LDAP_SUCCESS;
/* If no value, can't possibly be a conflict */
if ( (struct berval *)NULL == value )
return result;
filter = 0;
spb = 0;
BEGIN
int err;
int sres;
Slapi_Entry **entries;
static char *attrs[] = { "1.1", 0 };
/* Create the filter - this needs to be freed */
filter = create_filter(attrName, value, requiredObjectClass);
#ifdef DEBUG
slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name,
"SEARCH filter=%s\n", filter);
#endif
/* Perform the search using the new internal API */
spb = slapi_pblock_new();
if (!spb) { result = uid_op_error(2); break; }
slapi_search_internal_set_pb_ext(spb, baseDN, LDAP_SCOPE_SUBTREE,
filter, attrs, 0 /* attrs only */, NULL, NULL, plugin_identity, 0 /* actions */);
slapi_search_internal_pb(spb);
err = slapi_pblock_get(spb, SLAPI_PLUGIN_INTOP_RESULT, &sres);
if (err) { result = uid_op_error(3); break; }
/* Allow search to report that there is nothing in the subtree */
if (sres == LDAP_NO_SUCH_OBJECT) break;
/* Other errors are bad */
if (sres) { result = uid_op_error(3); break; }
err = slapi_pblock_get(spb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES,
&entries);
if (err) { result = uid_op_error(4); break; }
/*
* Look at entries returned. Any entry found must be the
* target entry or the constraint fails.
*/
for(;*entries;entries++)
{
#ifdef DEBUG
slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name,
"SEARCH entry dn=%s\n", slapi_entry_get_dn(*entries));
#endif
/*
* It is a Constraint Violation if any entry is found, unless
* the entry is the target entry (if any).
*/
if (!target || slapi_sdn_compare(slapi_entry_get_sdn(*entries), target) != 0)
{
result = LDAP_CONSTRAINT_VIOLATION;
break;
}
}
#ifdef DEBUG
slapi_log_error(SLAPI_LOG_PLUGIN, plugin_name,
"SEARCH complete result=%d\n", result);
#endif
END
/* Clean-up */
if (spb) {
slapi_free_search_results_internal(spb);
slapi_pblock_destroy(spb);
}
slapi_ch_free((void**)&filter);
return result;
}
