/**
* Returns a new HttpRequest object wrapping the client request
*/
static HttpRequest create_HttpRequest(Socket_T S) {
HttpRequest req= NULL;
char url[REQ_STRLEN];
char line[REQ_STRLEN];
char protocol[STRLEN];
char method[REQ_STRLEN];
if(socket_readln(S, line, REQ_STRLEN) == NULL) {
internal_error(S, SC_BAD_REQUEST, "No request found");
return NULL;
}
Str_chomp(line);
if(sscanf(line, "%1023s %1023s HTTP/%3[1.0]", method, url, protocol) != 3) {
internal_error(S, SC_BAD_REQUEST, "Cannot parse request");
return NULL;
}
if(strlen(url) >= MAX_URL_LENGTH) {
internal_error(S, SC_BAD_REQUEST, "[error] URL too long");
return NULL;
}
NEW(req);
req->S= S;
Util_urlDecode(url);
req->url= Str_dup(url);
req->method= Str_dup(method);
req->protocol= Str_dup(protocol);
create_headers(req);
if(!create_parameters(req)) {
destroy_HttpRequest(req);
internal_error(S, SC_BAD_REQUEST, "Cannot parse Request parameters");
return NULL;
}
return req;
}
/* Install the service */
int install_service(char *name, char *exe, char *flags) {
/* Open service manager */
SC_HANDLE services = open_service_manager();
if (! services) {
print_message(stderr, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);
return 2;
}
/* Get path of this program */
char path[MAX_PATH];
GetModuleFileName(0, path, MAX_PATH);
/* Construct command */
char command[CMD_LENGTH];
size_t pathlen = strlen(path);
if (pathlen + 1 >= VALUE_LENGTH) {
print_message(stderr, NSSM_MESSAGE_PATH_TOO_LONG, NSSM);
return 3;
}
if (_snprintf(command, sizeof(command), "\"%s\"", path) < 0) {
print_message(stderr, NSSM_MESSAGE_OUT_OF_MEMORY_FOR_IMAGEPATH);
return 4;
}
/* Work out directory name */
size_t len = strlen(exe);
size_t i;
for (i = len; i && exe[i] != '\\' && exe[i] != '/'; i--);
char dir[MAX_PATH];
memmove(dir, exe, i);
dir[i] = '\0';
/* Create the service */
SC_HANDLE service = CreateService(services, name, name, SC_MANAGER_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, command, 0, 0, 0, 0, 0);
if (! service) {
print_message(stderr, NSSM_MESSAGE_CREATESERVICE_FAILED);
CloseServiceHandle(services);
return 5;
}
/* Now we need to put the parameters into the registry */
if (create_parameters(name, exe, flags, dir)) {
print_message(stderr, NSSM_MESSAGE_CREATE_PARAMETERS_FAILED);
DeleteService(service);
CloseServiceHandle(services);
return 6;
}
set_service_recovery(service, name);
/* Cleanup */
CloseServiceHandle(service);
CloseServiceHandle(services);
print_message(stdout, NSSM_MESSAGE_SERVICE_INSTALLED, name);
return 0;
}
void parameter_cloud(Tree &T, Model &Mod, long Nrep, long length, double eps, Parameters &Parsim){
long iter;
float likel;
Parameters Par;
Alignment align;
Counts data;
double eps_pseudo = 0.001; // Amount added to compute the pseudo-counts.
// Initialize the parameters for simulation of K81 data for testing
Par = create_parameters(T);
// Obtaining the distribution of estimated parameters with EM
std::ofstream estpar;
estpar.open("est-par.dat", std::ios::out);
estpar.precision(15);
std::vector<double> param;
for (iter=0; iter < Nrep; iter++) {
random_data(T, Mod, Parsim, length, align);
get_counts(align, data);
add_pseudocounts(eps_pseudo, data);
// Runs EM
std::tie(likel, iter)= EMalgorithm(T, Mod, Par, data, eps);
// Choses the best permutation.
guess_permutation(T, Mod, Par);
get_free_param_vector(T, Mod, Par, param);
for (unsigned long k=0; k < param.size(); k++) {
estpar << param[k] << " ";
}
estpar << std::endl;
}
}
void parameter_test(Tree &T, Model &Mod, long Nrep, long length, double eps, std::vector<double> &pvals, std::string data_prefix, bool save_mc_exact){
long iter;
long i, r;
double df, C;
double distance, KL;
KL=0;
distance=0;
double likel;
Parameters Parsim, Par, Par_noperm;
Alignment align;
Counts data;
double eps_pseudo = 0.001; // Amount added to compute the pseudo-counts.
StateList sl;
bool save_data = (data_prefix != "");
std::string output_filename;
std::stringstream output_index;
std::ofstream logfile;
std::ofstream logdistfile;
std::ofstream out_chi2;
std::ofstream out_br;
std::ofstream out_brPerc;
std::ofstream out_pvals;
std::ofstream out_pvals_noperm;
std::ofstream out_qvals;
std::ofstream out_bound;
std::ofstream out_variances;
std::ofstream out_qvalsComb;
std::ofstream out_qvalsCombzscore;
std::ofstream out_covmatrix;
std::ofstream out_parest;
std::ofstream out_parsim;
std::vector<double> KLe;
std::vector<std::vector<double> > chi2_array; // an array of chi2 for every edge.
std::vector<std::vector<double> > mult_array; // an array of mult for every edge.
std::vector<std::vector<double> > br_array; // an array of br. length for every edge.
std::vector<std::vector<double> > br_arrayPerc; // an array of br. length for every edge.
std::vector<std::vector<double> > cota_array; // an array of upper bounds of the diff in lengths for every edge.
std::vector<std::vector<double> > pval_array; // an array of pvals for every edge.
std::vector<std::vector<double> > pval_noperm_array;
std::vector<std::vector<double> > qval_array; // an array of qvalues for every edge.
std::vector<std::vector<double> > variances_array; // an array of theoretical variances.
std::vector<std::vector<double> > parest_array; // array of estimated parameters
std::vector<std::vector<double> > parsim_array; // array of simulation parameters
// ci_binom ci_bin; // condfidence interval
std::vector<std::vector<ci_binom> > CIbinomial ; // vector of CIs
std::list<long> produced_nan;
long npars = T.nedges*Mod.df + Mod.rdf;
// Initializing pvals
pvals.resize(T.nedges);
// Initialize the parameters for simulation of K81 data for testing
Par = create_parameters(T);
Parsim = create_parameters(T);
// Initializing data structures
KLe.resize(T.nedges);
pval_array.resize(T.nedges);
pval_noperm_array.resize(T.nedges);
qval_array.resize(T.nedges);
chi2_array.resize(T.nedges);
mult_array.resize(T.nedges);
br_array.resize(T.nedges);
br_arrayPerc.resize(T.nedges);
cota_array.resize(T.nedges);
variances_array.resize(npars);
parest_array.resize(npars);
parsim_array.resize(npars);
// initialize to 0's
for (i=0; i < T.nedges; i++) {
pval_array[i].resize(Nrep, 0);
pval_noperm_array[i].resize(Nrep, 0);
qval_array[i].resize(Nrep, 0);
chi2_array[i].resize(Nrep, 0);
mult_array[i].resize(Nrep, 0);
br_array[i].resize(Nrep, 0);
br_arrayPerc[i].resize(Nrep, 0);
cota_array[i].resize(Nrep, 0);
}
for(i=0; i < npars; i++) {
variances_array[i].resize(Nrep, 0);
parest_array[i].resize(Nrep, 0);
parsim_array[i].resize(Nrep, 0);
}
// Information about the chi^2.
df = Mod.df;
C = get_scale_constant(Mod);
if (save_data) {
logfile.open((data_prefix + ".log").c_str(), std::ios::out);
logfile << "model: " << Mod.name << std::endl;
logfile << "length: " << length << std::endl;
logfile << "eps: " << eps << std::endl;
logfile << "nalpha: " << T.nalpha << std::endl;
logfile << "leaves: " << T.nleaves << std::endl;
logfile << "tree: " << T.tree_name << std::endl;
logfile << std::endl;
logdistfile.open((data_prefix + ".dist.log").c_str(), std::ios::out);
out_chi2.open(("out_chi2-" + data_prefix + ".txt").c_str(), std::ios::out);
out_br.open(("out_br-" + data_prefix + ".txt").c_str(), std::ios::out);
out_brPerc.open(("out_brPerc-" + data_prefix + ".txt").c_str(), std::ios::out);
out_pvals.open(("out_pvals-" + data_prefix + ".txt").c_str(), std::ios::out);
out_pvals_noperm.open(("out_pvals_noperm-" + data_prefix + ".txt").c_str(), std::ios::out);
out_qvals.open(("out_qvals-" + data_prefix + ".txt").c_str(), std::ios::out);
out_variances.open(("out_variances-" + data_prefix + ".txt").c_str(), std::ios::out);
out_parest.open(("out_params-est-" + data_prefix + ".txt").c_str(), std::ios::out);
out_parsim.open(("out_params-sim-" + data_prefix + ".txt").c_str(), std::ios::out);
out_bound.open(("out_bound-" + data_prefix + ".txt").c_str(), std::ios::out);
out_qvalsComb.open(("out_qvalsComb-" + data_prefix + ".txt").c_str(), std::ios::out);
out_qvalsCombzscore.open(("out_qvalsCombzscore-" + data_prefix + ".txt").c_str(), std::ios::out);
out_parsim.precision(15);
out_parest.precision(15);
out_variances.precision(15);
}
// uncomment the 2 following lines if want to fix the parameters
// random_parameters_length(T, Mod, Parsim);
//random_data(T, Mod, Parsim, length, align);
for (iter=0; iter < Nrep; iter++) {
std::cout << "iteration: " << iter << " \n";
// Produces an alignment from random parameters
random_parameters_length(T, Mod, Parsim);
random_data(T, Mod, Parsim, length, align);
get_counts(align, data);
add_pseudocounts(eps_pseudo, data);
// Saving data
if (save_data) {
output_index.str("");
output_index << iter;
output_filename = data_prefix + "-" + output_index.str();
save_alignment(align, output_filename + ".fa");
save_parameters(Parsim, output_filename + ".sim.dat");
}
// Runs the EM
std::tie(likel, iter) = EMalgorithm(T, Mod, Par, data, eps);
// If algorithm returns NaN skip this iteration.
if (boost::math::isnan(likel)) {
produced_nan.push_back(iter);
continue;
}
copy_parameters(Par, Par_noperm);
// Chooses the best permutation.
guess_permutation(T, Mod, Par);
distance = parameters_distance(Parsim, Par);
// estimated counts: Par ; original: Parsim
std::vector<double> counts_est;
counts_est.resize(T.nalpha, 0);
// calculate the cov matrix
std::vector<std::vector<double> > Cov;
Array2 Cov_br;
full_MLE_covariance_matrix(T, Mod, Parsim, length, Cov);
if(save_data) {
save_matrix(Cov, output_filename + ".cov.dat");
}
// Save the covariances in an array
std::vector<double> param;
std::vector<double> param_sim;
param.resize(npars);
param_sim.resize(npars);
get_free_param_vector(T, Mod, Par, param);
get_free_param_vector(T, Mod, Parsim, param_sim);
for(i=0; i < npars; i++) {
variances_array[i][iter] = Cov[i][i];
parsim_array[i][iter] = param_sim[i];
parest_array[i][iter] = param[i];
}
std::vector<double> xbranca, xbranca_noperm, mubranca;
double chi2_noperm;
xbranca.resize(Mod.df);
xbranca_noperm.resize(Mod.df);
mubranca.resize(Mod.df);
for (i=0; i < T.nedges; i++) {
r = 0; // row to be fixed
// Extracts the covariance matrix, 1 edge
branch_inverted_covariance_matrix(Mod, Cov, i, Cov_br);
get_branch_free_param_vector(T, Mod, Parsim, i, mubranca);
get_branch_free_param_vector(T, Mod, Par, i, xbranca);
get_branch_free_param_vector(T, Mod, Par_noperm, i, xbranca_noperm);
chi2_array[i][iter] = chi2_mult(mubranca, xbranca, Cov_br);
chi2_noperm = chi2_mult(mubranca, xbranca_noperm, Cov_br);
pval_array[i][iter] = pvalue_chi2(chi2_array[i][iter], Mod.df);
pval_noperm_array[i][iter] = pvalue_chi2(chi2_noperm, Mod.df);
br_array[i][iter] = T.edges[i].br - branch_length(Par.tm[i], T.nalpha);
br_arrayPerc[i][iter] = branch_length(Par.tm[i], T.nalpha)/T.edges[i].br;
// Upper bound on the parameter distance using multinomial:
// cota_array[i][iter] = bound_mult(Parsim.tm[i], Xm, length);
// and using the L2 bound
cota_array[i][iter] = branch_length_error_bound_mult(Parsim.tm[i], Par.tm[i]);
out_br << br_array[i][iter] << " ";
out_brPerc << br_arrayPerc[i][iter] << " ";
out_bound << cota_array[i][iter] << " ";
out_chi2 << chi2_array[i][iter] << " ";
}
out_chi2 << std::endl;
out_bound << std::endl;
out_br << std::endl;
out_brPerc << std::endl;
// Saves more data.
if (save_data) {
logfile << iter << ": " << distance << " " << KL << std::endl;
save_parameters(Par, output_filename + ".est.dat");
logdistfile << iter << ": ";
logdistfile << parameters_distance_root(Par, Parsim) << " ";
for(int j=0; j < T.nedges; j++) {
logdistfile << parameters_distance_edge(Par, Parsim, j) << " ";
}
logdistfile << std::endl;
}
} // close iter loop here
// Correct the p-values
for(i=0; i < T.nedges; i++) {
BH(pval_array[i], qval_array[i]);
//save them
}
if (save_mc_exact) {
for(long iter=0; iter < Nrep; iter++) {
for(long i=0; i < T.nedges; i++) {
out_pvals << pval_array[i][iter] << " ";
out_pvals_noperm << pval_noperm_array[i][iter] << " ";
out_qvals << qval_array[i][iter] << " ";
}
out_pvals << std::endl;
out_pvals_noperm << std::endl;
out_qvals << std::endl;
for(long i=0; i < npars; i++) {
out_variances << variances_array[i][iter] << " ";
out_parsim << parsim_array[i][iter] << " ";
out_parest << parest_array[i][iter] << " ";
}
out_variances << std::endl;
out_parsim << std::endl;
out_parest << std::endl;
}
}
// now combine the pvalues
for(i=0; i < T.nedges; i++) {
pvals[i] = Fisher_combined_pvalue(pval_array[i]);
//using the Zscore it goes like this: pvals[i] = Zscore_combined_pvalue(pval_array[i]);
if (save_mc_exact) { out_qvalsComb << pvals[i] << " " ;
out_qvalsCombzscore << Zscore_combined_pvalue(pval_array[i]) << " ";
}
}
// Close files
if (save_data) {
logdistfile.close();
logfile.close();
}
if (save_mc_exact) {
out_chi2.close();
out_bound.close();
out_variances.close();
out_parest.close();
out_parsim.close();
out_br.close();
out_brPerc.close();
out_pvals.close();
out_qvals.close();
out_qvalsComb.close();
out_qvalsCombzscore.close();
out_covmatrix.close();
}
// Warn if some EM's produced NaN.
if (produced_nan.size() > 0) {
std::cout << std::endl;
std::cout << "WARNING: Some iterations produced NaN." << std::endl;
std::list<long>::iterator it;
for (it = produced_nan.begin(); it != produced_nan.end(); it++) {
std::cout << *it << ", ";
}
std::cout << std::endl;
}
}
void run(std::string tree_filename, std::string fasta_filename, std::string model_name) {
Model Mod; // The model
Counts data; // the counts
Parameters Par; // the parameters
std::vector<double> br; // branch lengths
double eps = 1e-8; // The threshold for the EM algorithm.
Parameters Parsim; // used for simulating data.
std::vector<double> brsim; // branch lengths of simulated data.
std::vector<std::vector<double> > Cov; // Covariance matrix
std::vector<double> variances; // The variances
bool simulate;
bool nonident;
std::string parameters_filename;
std::string covariances_filename;
// initialize random number generator with time(0).
random_initialize();
parameters_filename = strip_extension(fasta_filename) + ".dat";
covariances_filename = strip_extension(fasta_filename) + ".cov";
// Creates the pointers to the model-specific functions.
Mod = create_model(model_name);
std::cout << "Model: " << Mod.name << std::endl;
// Reads the tree.
Tree T = read_tree(tree_filename);
// Prints the Tree
std::cout << "Tree:" << std::endl;
print_tree(T);
// Check for possible nonidentifiability issues.
nonident = nonident_warning(T);
// Initialize the parameters for simulation of K81 data for testing
Parsim = create_parameters(T);
if (fasta_filename == ":test") { // if fasta file is :test generate random data.
simulate = true;
// Warn
std::cout << "WARNING: Using simulated data " << std::endl << std::endl;
// Generate random parameters
random_parameters_length(T, Mod, Parsim);
// Simulate the data
data = random_fake_counts(T, 1000, Parsim);
// Prints branch-lengths for future check.
branch_lengths(Parsim, brsim);
std::cout << "Simulated branch lengths:" << std::endl;
print_vector(brsim);
} else { // otherwise read the data
simulate = false;
// Read the counts.
std::cout << "Reading fasta file:" << std::endl;
read_counts(T, data, fasta_filename);
add_pseudocounts(0.01, data);
std::cout << std::endl;
}
// Check whether the data and the tree match.
if (T.nalpha != data.nalpha || T.nleaves != data.nspecies) {
throw std::invalid_argument("The order of the sequences or their number and the phylogenetic tree do not match.");
}
//Par = create_parameters(T);
//print_parameters(Par);
//print_vector(Par.r);
//clock_t
long start_time, end_time;
// Runs the EM algorithm. Par is used as initial parameters.
// After execution, Par contains the MLE computed by the algorithm.
// for local max over multiple iterations
Parameters Parmax = Par;
Model Modmax = Mod;
float likelL = 0.0;
float likelMax = -1000000.0;
float timerec;
float timemax;
int outfiles; //whether to save output
std::cout << "Starting the EM algorithm: " << std::endl;
int s;
int S = 0; //count of cases with neg branches
int iter;
int iterMax;
for (int it_runs = 0; it_runs < 10; it_runs++) {
Par = create_parameters(T);
Mod = create_model(model_name);
std::cout << it_runs << ", " ;
start_time = clock();
std::tie(likelL, iter) = EMalgorithm(T, Mod, Par, data, eps);
end_time = clock();
//print_parameters(Par);
// Choses the best permutation.
guess_permutation(T, Mod, Par);
branch_lengths(Par, br);
//print_vector(br);
s = find_negative(br);
S +=s;
timerec = ((float)end_time - start_time) / CLOCKS_PER_SEC;
//assign the 1st iter time value, inc ase it's the best
if (it_runs == 0){
timemax = timerec;
iterMax = iter;
}
if (likelL > likelMax){
Parmax = Par;
Modmax = Mod;
timemax = timerec;
likelMax = likelL;
iterMax = iter;
}
}
// If parameters are not identifiable, the computation of the covariance matrix will
// fail as the Fisher info matrix will not be invertible.
if (!nonident) {
// Compute the covariance matrix using observed Fisher.
full_MLE_observed_covariance_matrix(T, Modmax, Parmax, data, Cov);
variances.resize(Cov.size());
for(unsigned int i=0; i < Cov.size(); i++) {
variances[i] = Cov[i][i];
}
// OUTPUT Save the sigmas into a file
//save_sigmas_to(covariances_filename, Cov);
}
std::cout << std::endl;
std::cout << "Finished." << std::endl;
std::cout << "Likelihood: " << log_likelihood(T, Parmax, data) << std::endl ;
std::cout << "Time: " << timemax << std::endl << std::endl;
std::cout << "negative branches: " << S << std::endl;
std::cout << "Iter: " << iterMax << std::endl;
//std::cout << "Branch lengths: " << std::endl;
//print_vector(br);
outfiles = 0;
if (!nonident && outfiles) {
std::cout << "Parameter variances: " << std::endl;
print_vector(variances);
}
std::cout << "Newick Tree:" << std::endl;
print_newick_tree(T, br);
// if is a simulation, print the L2 distance !
if (simulate) {
std::cout << "L2 distance: " << parameters_distance(Par, Parsim) << std::endl;
std::cout << "KL divergence: " << KL_divergence(T, Par, Parsim) << std::endl;
std::cout << std::endl;
}
// if it is not a simulation, store the parameters in a file !
if (!simulate && outfiles) {
std::fstream st;
st.precision(15);
st.setf(std::ios::fixed,std::ios::floatfield);
st.open(parameters_filename.c_str(), std::ios::out);
print_parameters(Par, st);
}
}
int bg_lv_load(bg_plugin_handle_t * ret,
const char * name, int plugin_flags, const char * window_id)
{
lv_priv_t * priv;
int i;
bg_visualization_plugin_t * p;
VisVideoAttributeOptions *vidoptions;
check_init();
/* Set up callbacks */
p = calloc(1, sizeof(*p));
ret->plugin_nc = (bg_plugin_common_t*)p;
ret->plugin = ret->plugin_nc;
if(plugin_flags & BG_PLUGIN_VISUALIZE_GL)
{
p->open_win = open_gl_lv;
p->draw_frame = draw_frame_gl_lv;
p->show_frame = show_frame_lv;
}
else
{
p->open_ov = open_ov_lv;
p->draw_frame = draw_frame_ov_lv;
}
p->update = update_lv;
p->close = close_lv;
p->set_callbacks = set_callbacks_lv;
p->common.get_parameters = get_parameters_lv;
p->common.set_parameter = set_parameter_lv;
/* Set up private data */
priv = calloc(1, sizeof(*priv));
ret->priv = priv;
priv->audio = visual_audio_new();
#if 0
priv->ov_callbacks.data = priv;
priv->ov_callbacks.key_callback = key_callback;
priv->ov_callbacks.key_release_callback = key_release_callback;
priv->ov_callbacks.button_callback = button_callback;
priv->ov_callbacks.button_release_callback = button_release_callback;
priv->ov_callbacks.motion_callback = motion_callback;
#endif
/* Remove gmerlin added prefix from the plugin name */
priv->actor = visual_actor_new(name + 7);
if(plugin_flags & BG_PLUGIN_VISUALIZE_GL)
{
priv->win = bg_x11_window_create(window_id);
priv->window_callbacks.data = priv;
priv->window_callbacks.size_changed = size_changed;
priv->window_callbacks.key_callback = key_callback;
priv->window_callbacks.key_release_callback = key_release_callback;
priv->window_callbacks.button_callback = button_callback;
priv->window_callbacks.button_release_callback = button_release_callback;
priv->window_callbacks.motion_callback = motion_callback;
/* Create an OpenGL context. For this, we need the OpenGL attributes */
vidoptions = visual_actor_get_video_attribute_options(priv->actor);
for(i = 0; i < VISUAL_GL_ATTRIBUTE_LAST; i++)
{
if((vidoptions->gl_attributes[i].mutated) && (bg_attributes[i] >= 0))
{
bg_x11_window_set_gl_attribute(priv->win, bg_attributes[i],
vidoptions->gl_attributes[i].value);
}
}
/* Set bogus dimensions, will be corrected by the size_callback */
bg_x11_window_set_size(priv->win, 640, 480);
bg_x11_window_realize(priv->win);
bg_x11_window_start_gl(priv->win);
bg_x11_window_set_gl(priv->win);
}
visual_actor_realize(priv->actor);
if(plugin_flags & BG_PLUGIN_VISUALIZE_GL)
bg_x11_window_unset_gl(priv->win);
priv->parameters = create_parameters(priv->actor, &priv->widgets, &priv->params);
priv->video = visual_video_new();
return 1;
}
bg_plugin_info_t * bg_lv_get_info(const char * filename)
{
int i;
VisVideoAttributeOptions *vidoptions;
bg_x11_window_t * win;
bg_plugin_info_t * ret;
VisPluginRef * ref;
VisList * list;
VisActor * actor;
VisPluginInfo * info;
char * tmp_string;
const char * actor_name = NULL;
check_init();
list = visual_plugin_get_registry();
/* Find out if there is a plugin matching the filename */
while((actor_name = visual_actor_get_next_by_name(actor_name)))
{
ref = visual_plugin_find(list, actor_name);
if(ref && !strcmp(ref->file, filename))
break;
}
if(!actor_name)
return NULL;
actor = visual_actor_new(actor_name);
if(!actor)
return NULL;
ret = calloc(1, sizeof(*ret));
info = visual_plugin_get_info(visual_actor_get_plugin(actor));
ret->name = bg_sprintf("vis_lv_%s", actor_name);
ret->long_name = gavl_strdup(info->name);
ret->type = BG_PLUGIN_VISUALIZATION;
ret->api = BG_PLUGIN_API_LV;
ret->description = bg_sprintf(TR("libvisual plugin"));
ret->module_filename = gavl_strdup(filename);
/* Optional info */
if(info->author && *info->author)
{
tmp_string = bg_sprintf(TR("\nAuthor: %s"),
info->author);
ret->description = gavl_strcat(ret->description, tmp_string);
free(tmp_string);
}
if(info->version && *info->version)
{
tmp_string = bg_sprintf(TR("\nVersion: %s"),
info->version);
ret->description = gavl_strcat(ret->description, tmp_string);
free(tmp_string);
}
if(info->about && *info->about)
{
tmp_string = bg_sprintf(TR("\nAbout: %s"),
info->about);
ret->description = gavl_strcat(ret->description, tmp_string);
free(tmp_string);
}
if(info->help && *info->help)
{
tmp_string = bg_sprintf(TR("\nHelp: %s"),
info->help);
ret->description = gavl_strcat(ret->description, tmp_string);
free(tmp_string);
}
if(info->license && *info->license)
{
tmp_string = bg_sprintf(TR("\nLicense: %s"),
info->license);
ret->description = gavl_strcat(ret->description, tmp_string);
free(tmp_string);
}
/* Check out if it's an OpenGL plugin */
if(visual_actor_get_supported_depth(actor) &
VISUAL_VIDEO_DEPTH_GL)
{
ret->flags |= BG_PLUGIN_VISUALIZE_GL;
win = bg_x11_window_create(NULL);
/* Create an OpenGL context. For this, we need the OpenGL attributes */
vidoptions = visual_actor_get_video_attribute_options(actor);
for(i = 0; i < VISUAL_GL_ATTRIBUTE_LAST; i++)
{
if((vidoptions->gl_attributes[i].mutated) && (bg_attributes[i] >= 0))
{
bg_x11_window_set_gl_attribute(win, bg_attributes[i],
vidoptions->gl_attributes[i].value);
}
}
/* Set bogus dimensions, will be corrected by the size_callback */
bg_x11_window_set_size(win, 640, 480);
bg_x11_window_realize(win);
if(!bg_x11_window_start_gl(win))
{
ret->flags |= BG_PLUGIN_UNSUPPORTED;
}
else
bg_x11_window_set_gl(win);
}
else
{
ret->flags |= BG_PLUGIN_VISUALIZE_FRAME;
win = NULL;
}
ret->priority = 1;
/* Must realize the actor to get the parameters */
if(!(ret->flags & BG_PLUGIN_UNSUPPORTED))
{
visual_actor_realize(actor);
ret->parameters =
create_parameters(actor, NULL, NULL);
visual_object_unref(VISUAL_OBJECT(actor));
}
if(win)
{
bg_x11_window_unset_gl(win);
bg_x11_window_stop_gl(win);
bg_x11_window_destroy(win);
}
return ret;
}
