error_info create_error(int err, const uint8_t *id, const char *format, ...)
{
va_list args;
va_start(args, format);
error_info error = create_info(err, dnet_dump_id_str(id), format, args);
va_end(args);
return error;
}
error_info create_error(int err, const char *format, ...)
{
va_list args;
va_start(args, format);
error_info error = create_info(err, 0, format, args);
va_end(args);
return error;
}
void throw_error(int err, const struct dnet_id &id, const char *format, ...)
{
va_list args;
va_start(args, format);
error_info error = create_info(err, dnet_dump_id(&id), format, args);
va_end(args);
error.throw_error();
}
void throw_error(int err, const char *format, ...)
{
va_list args;
va_start(args, format);
error_info error = create_info(err, 0, format, args);
va_end(args);
error.throw_error();
}
AstarArray* astar_search(void *ud, int src, int dst) {
AStarInfo *info = create_info(ud);
AstarNode *start = (AstarNode *)calloc(1, sizeof(*start));
start->index = src;
start->g = 0;
AstarArray *path = search(start, dst, info->open_set, info->close_set, ud);
info_release(&info);
return path;
}
error_info create_error(int err, const key &id, const char *format, ...)
{
va_list args;
va_start(args, format);
const char *id_str = id.by_id() ? dnet_dump_id(&id.id()) : id.remote().c_str();
error_info error = create_info(err, id_str, format, args);
va_end(args);
return error;
}
bool transpose_images(
struct comp_s *comp_img, struct mark_s *mark_img, struct intn_s *intn_img,
struct intn_s *diff_img, struct seams_s *seams, struct info_s *info,
void *heap
) {
transpose_comp(comp_img, heap, info);
// transpose_mark(mark_img, heap, info);
info->flags.transposed = !info->flags.transposed;
create_info(info, info->original_width, info->height, info->zoom);
set_mark_pointers(mark_img, info);
set_intn_pointers(intn_img, info);
set_diff_pointers(diff_img, info);
set_seams_pointers(seams, info);
return false;
}
void add_to_cache(cache_t cache, key_type key, val_type val, uint32_t val_size){
//adds in a new item in the location of the cache
key_type key_copy = make_copy(key,strlen((char*)key)+1);
key_val_s new_item;
new_item.key = key_copy;
new_item.val = make_copy(val,val_size);
new_item.val_size = val_size;
//give the policy the pointer to the key so that it can read the value of the key when
//the policy teels it about evictions in ids_to_delete_if_added
new_item.policy_info = create_info(cache->evic_policy,(void*)(key_copy),val_size);
assign_to_link(querry_hash(cache,key),new_item);
cache->mem_used += val_size;
cache->num_elements++;
//resizes table if load factor is over 0.5
if(cache->num_elements*2 > cache->table_size){
resize_table(cache,cache->table_size*2);
}
}
int gmx_pme_error(int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_pme_error[tt] estimates the error of the electrostatic forces",
"if using the sPME algorithm. The flag [TT]-tune[tt] will determine",
"the splitting parameter such that the error is equally",
"distributed over the real and reciprocal space part.",
"The part of the error that stems from self interaction of the particles "
"is computationally demanding. However, a good a approximation is to",
"just use a fraction of the particles for this term which can be",
"indicated by the flag [TT]-self[tt].[PAR]",
};
real fs=0.0; /* 0 indicates: not set by the user */
real user_beta=-1.0;
real fracself=1.0;
t_inputinfo info;
t_state state; /* The state from the tpr input file */
gmx_mtop_t mtop; /* The topology from the tpr input file */
t_inputrec *ir=NULL; /* The inputrec from the tpr file */
FILE *fp=NULL;
t_commrec *cr;
unsigned long PCA_Flags;
gmx_bool bTUNE=FALSE;
gmx_bool bVerbose=FALSE;
int seed=0;
static t_filenm fnm[] = {
{ efTPX, "-s", NULL, ffREAD },
{ efOUT, "-o", "error", ffWRITE },
{ efTPX, "-so", "tuned", ffOPTWR }
};
output_env_t oenv=NULL;
t_pargs pa[] = {
{ "-beta", FALSE, etREAL, {&user_beta},
"If positive, overwrite ewald_beta from [TT].tpr[tt] file with this value" },
{ "-tune", FALSE, etBOOL, {&bTUNE},
"Tune the splitting parameter such that the error is equally distributed between real and reciprocal space" },
{ "-self", FALSE, etREAL, {&fracself},
"If between 0.0 and 1.0, determine self interaction error from just this fraction of the charged particles" },
{ "-seed", FALSE, etINT, {&seed},
"Random number seed used for Monte Carlo algorithm when [TT]-self[tt] is set to a value between 0.0 and 1.0" },
{ "-v", FALSE, etBOOL, {&bVerbose},
"Be loud and noisy" }
};
#define NFILE asize(fnm)
cr = init_par(&argc,&argv);
#ifdef GMX_LIB_MPI
MPI_Barrier(MPI_COMM_WORLD);
#endif
if (MASTER(cr))
CopyRight(stderr,argv[0]);
PCA_Flags = PCA_NOEXIT_ON_ARGS;
PCA_Flags |= (MASTER(cr) ? 0 : PCA_QUIET);
parse_common_args(&argc,argv,PCA_Flags,
NFILE,fnm,asize(pa),pa,asize(desc),desc,
0,NULL,&oenv);
if (!bTUNE)
bTUNE = opt2bSet("-so",NFILE,fnm);
info.n_entries = 1;
/* Allocate memory for the inputinfo struct: */
create_info(&info);
info.fourier_sp[0] = fs;
/* Read in the tpr file and open logfile for reading */
if (MASTER(cr))
{
snew(ir,1);
read_tpr_file(opt2fn("-s",NFILE,fnm), &info, &state, &mtop, ir, user_beta,fracself);
fp=fopen(opt2fn("-o",NFILE,fnm),"w");
}
/* Check consistency if the user provided fourierspacing */
if (fs > 0 && MASTER(cr))
{
/* Recalculate the grid dimensions using fourierspacing from user input */
info.nkx[0] = 0;
info.nky[0] = 0;
info.nkz[0] = 0;
calc_grid(stdout,state.box,info.fourier_sp[0],&(info.nkx[0]),&(info.nky[0]),&(info.nkz[0]));
if ( (ir->nkx != info.nkx[0]) || (ir->nky != info.nky[0]) || (ir->nkz != info.nkz[0]) )
gmx_fatal(FARGS, "Wrong fourierspacing %f nm, input file grid = %d x %d x %d, computed grid = %d x %d x %d",
fs,ir->nkx,ir->nky,ir->nkz,info.nkx[0],info.nky[0],info.nkz[0]);
}
/* Estimate (S)PME force error */
/* Determine the volume of the simulation box */
if (MASTER(cr))
{
info.volume = det(state.box);
calc_recipbox(state.box,info.recipbox);
info.natoms = mtop.natoms;
info.bTUNE = bTUNE;
}
if (PAR(cr))
bcast_info(&info, cr);
/* Get an error estimate of the input tpr file and do some tuning if requested */
estimate_PME_error(&info, &state, &mtop, fp, bVerbose, seed, cr);
if (MASTER(cr))
{
/* Write out optimized tpr file if requested */
if ( opt2bSet("-so",NFILE,fnm) || bTUNE )
{
ir->ewald_rtol=info.ewald_rtol[0];
write_tpx_state(opt2fn("-so",NFILE,fnm),ir,&state,&mtop);
}
please_cite(fp,"Wang2010");
fclose(fp);
}
if (gmx_parallel_env_initialized())
{
gmx_finalize();
}
return 0;
}
GtkWidget *
create_canvas_arrowhead (void)
{
GtkWidget *vbox;
GtkWidget *w;
GtkWidget *frame;
GtkWidget *canvas;
GooCanvasItemModel *root, *item;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_widget_show (vbox);
w = gtk_label_new ("This demo allows you to edit arrowhead shapes. Drag the little boxes\n"
"to change the shape of the line and its arrowhead. You can see the\n"
"arrows at their normal scale on the right hand side of the window.");
gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
w = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), w, TRUE, TRUE, 0);
gtk_widget_show (w);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (w), frame);
gtk_widget_show (frame);
canvas = goo_canvas_new ();
g_signal_connect (canvas, "item_created",
G_CALLBACK (on_item_created), NULL);
root = goo_canvas_group_model_new (NULL, NULL);
goo_canvas_set_root_item_model (GOO_CANVAS (canvas), root);
g_object_unref (root);
gtk_widget_set_size_request (canvas, 500, 350);
goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 500, 350);
gtk_container_add (GTK_CONTAINER (frame), canvas);
gtk_widget_show (canvas);
g_object_set_data (G_OBJECT (canvas), "width",
GINT_TO_POINTER (DEFAULT_WIDTH));
g_object_set_data (G_OBJECT (canvas), "shape_a",
GINT_TO_POINTER (DEFAULT_SHAPE_A));
g_object_set_data (G_OBJECT (canvas), "shape_b",
GINT_TO_POINTER (DEFAULT_SHAPE_B));
g_object_set_data (G_OBJECT (canvas), "shape_c",
GINT_TO_POINTER (DEFAULT_SHAPE_C));
/* Big arrow */
item = goo_canvas_polyline_model_new_line (root,
LEFT, MIDDLE, RIGHT, MIDDLE,
"stroke_color", "mediumseagreen",
"end-arrow", TRUE,
NULL);
g_object_set_data (G_OBJECT (canvas), "big_arrow", item);
/* Arrow outline */
item = goo_canvas_polyline_model_new (root, TRUE, 0,
"stroke_color", "black",
"line-width", 2.0,
"line-cap", CAIRO_LINE_CAP_ROUND,
"line-join", CAIRO_LINE_JOIN_ROUND,
NULL);
g_object_set_data (G_OBJECT (canvas), "outline", item);
/* Drag boxes */
create_drag_box (canvas, root, "width_drag_box");
create_drag_box (canvas, root, "shape_a_drag_box");
create_drag_box (canvas, root, "shape_b_c_drag_box");
/* Dimensions */
create_dimension (canvas, root, "width_arrow", "width_text", GOO_CANVAS_ANCHOR_E);
create_dimension (canvas, root, "shape_a_arrow", "shape_a_text", GOO_CANVAS_ANCHOR_N);
create_dimension (canvas, root, "shape_b_arrow", "shape_b_text", GOO_CANVAS_ANCHOR_N);
create_dimension (canvas, root, "shape_c_arrow", "shape_c_text", GOO_CANVAS_ANCHOR_W);
/* Info */
create_info (canvas, root, "width_info", LEFT, 260);
create_info (canvas, root, "shape_a_info", LEFT, 280);
create_info (canvas, root, "shape_b_info", LEFT, 300);
create_info (canvas, root, "shape_c_info", LEFT, 320);
/* Division line */
goo_canvas_polyline_model_new_line (root, RIGHT + 50, 0, RIGHT + 50, 1000,
"fill_color", "black",
"line-width", 2.0,
NULL);
/* Sample arrows */
create_sample_arrow (canvas, root, "sample_1",
RIGHT + 100, 30, RIGHT + 100, MIDDLE - 30);
create_sample_arrow (canvas, root, "sample_2",
RIGHT + 70, MIDDLE, RIGHT + 130, MIDDLE);
create_sample_arrow (canvas, root, "sample_3",
RIGHT + 70, MIDDLE + 30, RIGHT + 130, MIDDLE + 120);
/* Done! */
set_arrow_shape (GOO_CANVAS (canvas));
return vbox;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
gint sel_x1, sel_y1, sel_x2, sel_y2;
gint img_height, img_width, img_bpp, img_has_alpha;
GimpDrawable *drawable;
GimpRunMode run_mode;
GimpPDBStatusType status;
*nreturn_vals = 1;
*return_vals = values;
status = GIMP_PDB_SUCCESS;
if (param[0].type != GIMP_PDB_INT32)
status = GIMP_PDB_CALLING_ERROR;
run_mode = param[0].data.d_int32;
INIT_I18N ();
if (param[2].type != GIMP_PDB_DRAWABLE)
status = GIMP_PDB_CALLING_ERROR;
drawable = gimp_drawable_get (param[2].data.d_drawable);
img_width = gimp_drawable_width (drawable->drawable_id);
img_height = gimp_drawable_height (drawable->drawable_id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
if (!gimp_drawable_is_rgb (drawable->drawable_id))
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
{
gr = g_rand_new ();
memset (&qbist_info, 0, sizeof (qbist_info));
create_info (&qbist_info.info);
qbist_info.oversampling = 4;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &qbist_info);
/* Get information from the dialog */
if (dialog_run ())
{
status = GIMP_PDB_SUCCESS;
gimp_set_data (PLUG_IN_PROC, &qbist_info, sizeof (QbistInfo));
}
else
status = GIMP_PDB_EXECUTION_ERROR;
break;
case GIMP_RUN_NONINTERACTIVE:
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &qbist_info);
status = GIMP_PDB_SUCCESS;
break;
default:
status = GIMP_PDB_CALLING_ERROR;
break;
}
if (status == GIMP_PDB_SUCCESS)
{
GimpPixelRgn imagePR;
gpointer pr;
gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width () - 1) /
gimp_tile_width ());
gimp_pixel_rgn_init (&imagePR, drawable,
0, 0, img_width, img_height, TRUE, TRUE);
optimize (&qbist_info.info);
gimp_progress_init (_("Qbist"));
for (pr = gimp_pixel_rgns_register (1, &imagePR);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
gint row;
for (row = 0; row < imagePR.h; row++)
{
qbist (&qbist_info.info,
imagePR.data + row * imagePR.rowstride,
imagePR.x,
imagePR.y + row,
imagePR.w,
sel_x2 - sel_x1,
sel_y2 - sel_y1,
imagePR.bpp,
qbist_info.oversampling);
}
gimp_progress_update ((gfloat) (imagePR.y - sel_y1) /
(gfloat) (sel_y2 - sel_y1));
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1,
(sel_x2 - sel_x1), (sel_y2 - sel_y1));
gimp_displays_flush ();
}
g_rand_free (gr);
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
int gmx_pme_error(int argc,char *argv[])
{
const char *desc[] = {
"g_pme_error estimates the error of the electrostatic forces",
"if using the SPME algorithm. The flag [TT]-tune[tt] will determine",
"the splitting parameter such that the error is equally",
"distributed over the real and reciprocal space part.",
"As a part of the error stems from self interaction of the particles "
"and is computationally very demanding a good a approximation is possible",
"if just a fraction of the particles is used to calculate the average",
"of this error by using the flag [TT]-self[tt].[PAR]",
};
int repeats=2;
real fs=0.0; /* 0 indicates: not set by the user */
real user_beta=-1.0;
real fracself=-1.0;
t_perf **perfdata;
t_inputinfo info;
t_state state; /* The state from the tpr input file */
gmx_mtop_t mtop; /* The topology from the tpr input file */
t_inputrec *ir=NULL; /* The inputrec from the tpr file */
FILE *fp=NULL;
t_commrec *cr;
unsigned long PCA_Flags;
gmx_bool bTUNE=FALSE;
static t_filenm fnm[] = {
/* g_tune_pme */
{ efTPX, "-s", NULL, ffREAD },
{ efOUT, "-o", "error", ffWRITE },
{ efTPX, "-so", "tuned", ffOPTWR }
};
output_env_t oenv=NULL;
t_pargs pa[] = {
/***********************/
/* g_tune_pme options: */
/***********************/
{ "-beta", FALSE, etREAL, {&user_beta},
"If positive, overwrite ewald_beta from tpr file with this value" },
{ "-tune", FALSE, etBOOL, {&bTUNE},
"If flag is set the splitting parameter will be tuned to distribute the error equally in real and rec. space" },
{ "-self", FALSE, etREAL, {&fracself},
"If positive, determine selfinteraction error just over this fraction (default=1.0)" }
};
#define NFILE asize(fnm)
cr = init_par(&argc,&argv);
if (MASTER(cr))
CopyRight(stderr,argv[0]);
PCA_Flags = PCA_NOEXIT_ON_ARGS;
PCA_Flags |= (MASTER(cr) ? 0 : PCA_QUIET);
parse_common_args(&argc,argv,PCA_Flags,
NFILE,fnm,asize(pa),pa,asize(desc),desc,
0,NULL,&oenv);
if (!bTUNE)
bTUNE = opt2bSet("-so",NFILE,fnm);
info.n_entries = 1;
/* Allocate memory for the inputinfo struct: */
create_info(&info);
info.fourier_sp[0] = fs;
/* Read in the tpr file and open logfile for reading */
if (MASTER(cr))
{
snew(ir,1);
read_tpr_file(opt2fn("-s",NFILE,fnm), &info, &state, &mtop, ir, user_beta,fracself);
fp=fopen(opt2fn("-o",NFILE,fnm),"w");
}
/* Check consistency if the user provided fourierspacing */
if (fs > 0 && MASTER(cr))
{
/* Recalculate the grid dimensions using fourierspacing from user input */
info.nkx[0] = 0;
info.nky[0] = 0;
info.nkz[0] = 0;
calc_grid(stdout,state.box,info.fourier_sp[0],&(info.nkx[0]),&(info.nky[0]),&(info.nkz[0]));
if ( (ir->nkx != info.nkx[0]) || (ir->nky != info.nky[0]) || (ir->nkz != info.nkz[0]) )
gmx_fatal(FARGS, "Wrong fourierspacing %f nm, input file grid = %d x %d x %d, computed grid = %d x %d x %d",
fs,ir->nkx,ir->nky,ir->nkz,info.nkx[0],info.nky[0],info.nkz[0]);
}
/* Estimate (S)PME force error */
/* Determine the volume of the simulation box */
if (MASTER(cr))
{
info.volume = det(state.box);
calc_recipbox(state.box,info.recipbox);
info.natoms = mtop.natoms;
info.bTUNE = bTUNE;
}
if (PAR(cr))
bcast_info(&info, cr);
/* Get an error estimate of the input tpr file */
estimate_PME_error(&info, &state, &mtop, fp, cr);
if (MASTER(cr))
{
ir->ewald_rtol=info.ewald_rtol[0];
write_tpx_state(opt2fn("-so",NFILE,fnm),ir,&state,&mtop);
please_cite(fp,"Wang2010");
fclose(fp);
}
if (gmx_parallel_env_initialized())
{
gmx_finalize();
}
return 0;
}
#include "audiocontroller.hpp"
#include "audiomixer.hpp"
#include "mpv_helper.hpp"
extern "C" {
#include <libswresample/swresample.h>
#include <libavutil/opt.h>
#include <audio/filter/af.h>
#include <audio/fmt-conversion.h>
}
#include "log.hpp"
DECLARE_LOG_CONTEXT(Audio)
af_info create_info();
af_info af_info_dummy = create_info();
struct cmplayer_af_priv { AudioController *ac; char *address; int use_scaler; int layout; };
static AudioController *priv(af_instance *af) { return static_cast<cmplayer_af_priv*>(af->priv)->ac; }
static bool isSupported(int type) {
switch (type) {
case AF_FORMAT_S16P:
case AF_FORMAT_S32P:
case AF_FORMAT_FLOATP:
case AF_FORMAT_DOUBLEP:
case AF_FORMAT_S16:
case AF_FORMAT_S32:
case AF_FORMAT_FLOAT:
case AF_FORMAT_DOUBLE:
return true;
default:
return false;
