static int negotiate_video (VisActor *actor, int noevent) { VisActorPlugin *actplugin = get_actor_plugin (actor); int tmpwidth, tmpheight, tmppitch; tmpwidth = actor->video->width; tmpheight = actor->video->height; tmppitch = actor->video->pitch; /* Pump the resize events and handle all the pending events */ actplugin->requisition (visual_actor_get_plugin (actor), &actor->video->width, &actor->video->height); if (noevent == FALSE) { visual_event_queue_add_resize (&actor->plugin->eventqueue, actor->video, actor->video->width, actor->video->height); visual_plugin_events_pump (actor->plugin); } /* Size fitting enviroment */ if (tmpwidth != actor->video->width || tmpheight != actor->video->height) { if (actor->video->depth != VISUAL_VIDEO_DEPTH_GL) { actor->fitting = visual_video_new_with_buffer (actor->video->width, actor->video->height, actor->video->depth); } visual_video_set_dimension (actor->video, tmpwidth, tmpheight); } /* Set the pitch seen this is the framebuffer context */ visual_video_set_pitch (actor->video, tmppitch); return VISUAL_OK; }
/** * Gives a pointer to the palette within the VisActor. This can be needed to set a palette on the target * display when it's in index mode. * * @see VisPalette * * @param actor Pointer to a VisActor of which the palette is needed. * * @return Pointer to the palette structure on succes or NULL on failure. Also it's possible that NULL * is returned when the plugin is running in a full color mode or openGL. The returned palette is * read only. */ VisPalette *visual_actor_get_palette (VisActor *actor) { VisActorPlugin *actplugin; visual_log_return_val_if_fail (actor != NULL, NULL); actplugin = get_actor_plugin (actor); if (actplugin == NULL) { visual_log (VISUAL_LOG_CRITICAL, _("The given actor does not reference any actor plugin")); return NULL; } if (actor->transform != NULL && actor->video->depth == VISUAL_VIDEO_DEPTH_8BIT) { return actor->ditherpal; } else { return actplugin->palette (visual_actor_get_plugin (actor)); } return NULL; }
/** VisActor.actorNew() */ JNIEXPORT jint JNICALL Java_org_libvisual_android_VisActor_actorNew(JNIEnv * env, jobject obj, jstring name) { LOGI("VisActor.actorNew()"); /* result */ VisActor *a = NULL; /* get name string */ jboolean isCopy; const char *actorName = (*env)->GetStringUTFChars(env, name, &isCopy); /* actor valid ? */ if(!(visual_plugin_registry_has_plugin(VISUAL_PLUGIN_TYPE_ACTOR, actorName))) { LOGE("Invalid actor-plugin: \"%s\"", actorName); goto _van_exit; } /* create new actor */ a = visual_actor_new(actorName); /* set random seed */ VisPluginData *plugin_data = visual_actor_get_plugin(a); VisRandomContext *r_context = visual_plugin_get_random_context (plugin_data); visual_random_context_set_seed(r_context, time(NULL)); _van_exit: (*env)->ReleaseStringUTFChars(env, name, actorName); return (jint) a; }
int pipeline_container_propagate_event (LVAVSPipelineContainer *container, VisEvent *event) { VisListEntry *le = NULL; VisEventQueue *pluginqueue; LVAVSPipelineElement *element; while ((element = visual_list_next (container->members, &le)) != NULL) { switch (element->type) { case LVAVS_PIPELINE_ELEMENT_TYPE_ACTOR: pluginqueue = visual_plugin_get_eventqueue (visual_actor_get_plugin (element->data.actor)); visual_object_ref (VISUAL_OBJECT (event)); visual_event_queue_add (pluginqueue, event); break; case LVAVS_PIPELINE_ELEMENT_TYPE_TRANSFORM: pluginqueue = visual_plugin_get_eventqueue (visual_actor_get_plugin (element->data.actor)); visual_object_ref (VISUAL_OBJECT (event)); visual_event_queue_add (pluginqueue, event); break; case LVAVS_PIPELINE_ELEMENT_TYPE_CONTAINER: pipeline_container_propagate_event (LVAVS_PIPELINE_CONTAINER (element), event); break; default: break; } } return VISUAL_OK; }
int pipeline_container_realize (LVAVSPipelineContainer *container) { VisListEntry *le = NULL; LVAVSPipelineElement *element; while ((element = visual_list_next (container->members, &le)) != NULL) { switch (element->type) { case LVAVS_PIPELINE_ELEMENT_TYPE_NULL: break; case LVAVS_PIPELINE_ELEMENT_TYPE_ACTOR: visual_actor_realize (element->data.actor); visual_param_container_copy_match (visual_plugin_get_params ( visual_actor_get_plugin (element->data.actor)), element->params); break; case LVAVS_PIPELINE_ELEMENT_TYPE_TRANSFORM: visual_transform_realize (element->data.transform); visual_param_container_copy_match (visual_plugin_get_params ( visual_transform_get_plugin (element->data.transform)), element->params); break; case LVAVS_PIPELINE_ELEMENT_TYPE_MORPH: visual_morph_realize (element->data.morph); break; case LVAVS_PIPELINE_ELEMENT_TYPE_RENDERSTATE: break; case LVAVS_PIPELINE_ELEMENT_TYPE_CONTAINER: pipeline_container_realize (LVAVS_PIPELINE_CONTAINER (element)); break; default: visual_log (VISUAL_LOG_CRITICAL, "Invalid LVAVSPipelineElementType"); break; } } return 0; }
static int button_callback(void * data, int x, int y, int button, int mask) { VisEventQueue *eventqueue; lv_priv_t * priv = (lv_priv_t*)data; eventqueue = visual_plugin_get_eventqueue(visual_actor_get_plugin(priv->actor)); visual_event_queue_add_mousebutton(eventqueue, button, VISUAL_MOUSE_DOWN, x, y); if(priv->ov_callbacks && priv->ov_callbacks->button_callback) { priv->ov_callbacks->button_callback(priv->ov_callbacks->data, x, y, button, mask); } return 1; }
static int negotiate_video_with_unsupported_depth (VisActor *actor, int rundepth, int noevent, int forced) { VisActorPlugin *actplugin = get_actor_plugin (actor); int depthflag = visual_actor_get_supported_depth (actor); /* Depth transform enviroment, it automaticly * fits size because it can use the pitch from * the dest video context */ actor->transform = visual_video_new (); visual_log (VISUAL_LOG_INFO, _("run depth %d forced %d\n"), rundepth, forced); if (forced == TRUE) visual_video_set_depth (actor->transform, rundepth); else visual_video_set_depth (actor->transform, visual_video_depth_get_highest_nogl (depthflag)); visual_log (VISUAL_LOG_INFO, _("transpitch1 %d depth %d bpp %d"), actor->transform->pitch, actor->transform->depth, actor->transform->bpp); /* If there is only GL (which gets returned by highest nogl if * nothing else is there, stop here */ if (actor->transform->depth == VISUAL_VIDEO_DEPTH_GL) return -VISUAL_ERROR_ACTOR_GL_NEGOTIATE; visual_video_set_dimension (actor->transform, actor->video->width, actor->video->height); visual_log (VISUAL_LOG_INFO, _("transpitch2 %d %d"), actor->transform->width, actor->transform->pitch); actplugin->requisition (visual_actor_get_plugin (actor), &actor->transform->width, &actor->transform->height); visual_log (VISUAL_LOG_INFO, _("transpitch3 %d"), actor->transform->pitch); if (noevent == FALSE) { visual_event_queue_add_resize (&actor->plugin->eventqueue, actor->transform, actor->transform->width, actor->transform->height); visual_plugin_events_pump (actor->plugin); } else { /* Normally a visual_video_set_dimension get's called within the * event handler, but we won't come there right now so we've * got to set the pitch ourself */ visual_video_set_dimension (actor->transform, actor->transform->width, actor->transform->height); } visual_log (VISUAL_LOG_INFO, _("rundepth: %d transpitch %d\n"), rundepth, actor->transform->pitch); visual_video_allocate_buffer (actor->transform); if (actor->video->depth == VISUAL_VIDEO_DEPTH_8BIT) actor->ditherpal = visual_palette_new (256); return VISUAL_OK; }
static int key_release_callback(void * data, int key, int mask) { VisEventQueue *eventqueue; int lv_key, lv_mask; lv_priv_t * priv = (lv_priv_t*)data; if(!get_key_code(key, mask, &lv_key, &lv_mask)) return 0; eventqueue = visual_plugin_get_eventqueue(visual_actor_get_plugin(priv->actor)); visual_event_queue_add_keyboard(eventqueue, lv_key, lv_mask, VISUAL_KEY_UP); return 1; }
int main (int argc, char **argv) { // print warm welcome std::cerr << argv[0] << " v0.1\n"; // initialize libvisual once (this is meant to be called only once, // visual_init() after visual_quit() results in undefined state) visual_log_set_verbosity(VISUAL_LOG_DEBUG); visual_init (&argc, &argv); try { // parse commandline arguments if (_parse_args(argc, argv) != EXIT_SUCCESS) throw std::runtime_error ("Failed to parse arguments"); // create new VisBin for video output VisBin *bin = visual_bin_new(); visual_bin_set_supported_depth(bin, VISUAL_VIDEO_DEPTH_ALL); visual_bin_switch_set_style(bin, VISUAL_SWITCH_STYLE_MORPH); // initialize actor plugin std::cerr << "Loading actor '" << actor_name << "'...\n"; VisActor *actor = visual_actor_new (actor_name.c_str ()); if (!actor) throw std::runtime_error ("Failed to load actor '" + actor_name + "'"); // Set random seed if (have_seed) { VisPluginData *plugin_data = visual_actor_get_plugin(actor); VisRandomContext *r_context = visual_plugin_get_random_context (plugin_data); visual_random_context_set_seed (r_context, seed); seed++; } // initialize input plugin std::cerr << "Loading input '" << input_name << "'...\n"; VisInput *input = visual_input_new(input_name.c_str()); if (!input) { throw std::runtime_error ("Failed to load input '" + input_name + "'"); } // Pick the best display depth int depthflag = visual_actor_get_supported_depth (actor); VisVideoDepth depth; if (depthflag == VISUAL_VIDEO_DEPTH_GL) { depth = visual_video_depth_get_highest (depthflag); } else { depth = visual_video_depth_get_highest_nogl (depthflag); } visual_bin_set_depth (bin, depth); VisVideoAttributeOptions const* vidoptions = visual_actor_get_video_attribute_options(actor); // initialize display SADisplay display (driver_name); // create display display.create(depth, vidoptions, width, height, true); VisVideo *video = display.get_video(); if(!video) throw std::runtime_error("Failed to get VisVideo from display"); // put it all together visual_bin_connect(bin, actor, input); visual_bin_set_video(bin, video); visual_bin_realize(bin); visual_bin_sync(bin, FALSE); visual_bin_depth_changed(bin); // get a queue to handle events VisEventQueue localqueue; // main loop bool running = true; bool visible = true; while (running) { LV::Event ev; // Handle all events display.drain_events(localqueue); LV::EventQueue* pluginqueue = visual_plugin_get_eventqueue(visual_actor_get_plugin (bin->actor)); while (localqueue.poll(ev)) { if(ev.type != VISUAL_EVENT_RESIZE) pluginqueue->add (ev); switch (ev.type) { case VISUAL_EVENT_PARAM: { break; } case VISUAL_EVENT_RESIZE: { display.lock(); width = ev.event.resize.width; height = ev.event.resize.height; display.create(depth, vidoptions, width, height, true); video = display.get_video (); visual_bin_set_video (bin, video); visual_actor_video_negotiate (bin->actor, depth, FALSE, FALSE); display.unlock(); break; } case VISUAL_EVENT_MOUSEMOTION: { break; } case VISUAL_EVENT_MOUSEBUTTONDOWN: { // switch to next actor v_cycleActor(1); v_cycleMorph(); visual_bin_set_morph_by_name(bin, morph_name.c_str()); visual_bin_switch_actor_by_name(bin, actor_name.c_str()); // get new actor actor = visual_bin_get_actor(bin); // handle depth of new actor depthflag = visual_actor_get_supported_depth(actor); if (depthflag == VISUAL_VIDEO_DEPTH_GL) { visual_bin_set_depth(bin, VISUAL_VIDEO_DEPTH_GL); } else { depth = visual_video_depth_get_highest(depthflag); if ((bin->depthflag & depth) > 0) visual_bin_set_depth(bin, depth); else visual_bin_set_depth(bin, visual_video_depth_get_highest_nogl(bin->depthflag)); } bin->depthforcedmain = bin->depth; break; } case VISUAL_EVENT_MOUSEBUTTONUP: { break; } case VISUAL_EVENT_KEYDOWN: { switch(ev.event.keyboard.keysym.sym) { case VKEY_ESCAPE: { running = false; break; } case VKEY_TAB: { break; } default: break; } break; } case VISUAL_EVENT_KEYUP: { break; } case VISUAL_EVENT_QUIT: { running = FALSE; break; } case VISUAL_EVENT_VISIBILITY: { visible = ev.event.visibility.is_visible; break; } default: { break; } } } if (visual_bin_depth_changed(bin)) { display.lock(); display.create(depth, vidoptions, width, height, true); VisVideo *video = display.get_video(); visual_bin_set_video(bin, video); visual_bin_sync(bin, TRUE); display.unlock(); } // Do a run cycle if (!visible) continue; display.lock(); visual_bin_run(bin); display.unlock(); display.update_all(); display.set_fps_limit(framerate); } } catch (std::exception& error) { std::cerr << error.what () << std::endl; } //printf ("Total frames: %d, average fps: %f\n", display_fps_total (display), display_fps_average (display)); visual_quit (); return EXIT_SUCCESS; }
/** * This is called to run a VisActor. It also pump it's events when needed, checks for new song events and also does the fitting * and depth transformation actions when needed. * * Every run cycle one frame is created, so this function needs to be used in the main draw loop of the application. * * @param actor Pointer to a VisActor that needs to be runned. * @param audio Pointer to a VisAudio that contains all the audio data. * * return VISUAL_OK on succes, -VISUAL_ERROR_ACTOR_NULL, -VISUAL_ERROR_ACTOR_VIDEO_NULL, -VISUAL_ERROR_NULL or * -VISUAL_ERROR_ACTOR_PLUGIN_NULL on failure. */ int visual_actor_run (VisActor *actor, VisAudio *audio) { VisActorPlugin *actplugin; VisPluginData *plugin; VisVideo *video; VisVideo *transform; VisVideo *fitting; /* We don't check for video, because we don't always need a video */ /* * Really? take a look at visual_video_set_palette bellow */ visual_log_return_val_if_fail (actor != NULL, -VISUAL_ERROR_ACTOR_NULL); visual_log_return_val_if_fail (actor->video != NULL, -VISUAL_ERROR_ACTOR_VIDEO_NULL); visual_log_return_val_if_fail (audio != NULL, -VISUAL_ERROR_NULL); actplugin = get_actor_plugin (actor); plugin = visual_actor_get_plugin (actor); if (actplugin == NULL) { visual_log (VISUAL_LOG_CRITICAL, _("The given actor does not reference any actor plugin")); return -VISUAL_ERROR_ACTOR_PLUGIN_NULL; } /* Songinfo handling */ if(0) /*FIXME*/if (visual_songinfo_compare (&actor->songcompare, &actplugin->songinfo) == FALSE || actor->songcompare.elapsed != actplugin->songinfo.elapsed) { visual_songinfo_mark (&actplugin->songinfo); visual_event_queue_add_newsong ( visual_plugin_get_eventqueue (plugin), &actplugin->songinfo); visual_songinfo_free_strings (&actor->songcompare); visual_songinfo_copy (&actor->songcompare, &actplugin->songinfo); } video = actor->video; transform = actor->transform; fitting = actor->fitting; /* * This needs to happen before palette, render stuff, always, period. * Also internal vars can be initialized when params have been set in init on the param * events in the event loop. */ visual_plugin_events_pump (actor->plugin); visual_video_set_palette (video, visual_actor_get_palette (actor)); /* Set the palette to the target video */ video->pal = visual_actor_get_palette (actor); /* Yeah some transformation magic is going on here when needed */ if (transform != NULL && (transform->depth != video->depth)) { actplugin->render (plugin, transform, audio); if (transform->depth == VISUAL_VIDEO_DEPTH_8BIT) { visual_video_set_palette (transform, visual_actor_get_palette (actor)); visual_video_depth_transform (video, transform); } else { visual_video_set_palette (transform, actor->ditherpal); visual_video_depth_transform (video, transform); } } else { if (fitting != NULL && (fitting->width != video->width || fitting->height != video->height)) { actplugin->render (plugin, fitting, audio); visual_video_blit_overlay (video, fitting, 0, 0, FALSE); } else { actplugin->render (plugin, video, audio); } } return VISUAL_OK; }
/** VisActor.actorGetPlugin() */ JNIEXPORT jint JNICALL Java_org_libvisual_android_VisActor_actorGetPlugin(JNIEnv * env, jobject obj, jint actor) { VisActor *a = (VisActor *) actor; return (jint) visual_actor_get_plugin(a); }
int main (int argc, char **argv) { SADisplay *display; VisVideo *video; VisInput *input; VisActor *actor; VisEventQueue *localqueue; VisVideoAttributeOptions *vidoptions; int running = TRUE; int fullscreen = FALSE; int visible = TRUE; int depth; //visual_mem_alloc_install_vtable (visual_mem_alloc_vtable_profile ()); visual_init (&argc, &argv); display = display_new (sdl_driver_new ()); /* Libvisual stuff */ if (argc > 1) actor = visual_actor_new (argv[1]); else actor = visual_actor_new ("projectM"); if (argc > 3) { depth = visual_video_depth_enum_from_value (atoi (argv[3])); } else depth = visual_video_depth_get_highest (visual_actor_get_supported_depth (actor)); vidoptions = visual_actor_get_video_attribute_options (actor); display_create (display, depth, vidoptions, 480, 360, TRUE); visual_actor_realize (actor); video = display_get_video (display); visual_actor_set_video (actor, video); visual_actor_video_negotiate (actor, 0, FALSE, FALSE); if (argc > 2) input = visual_input_new (argv[2]); else input = visual_input_new ("alsa"); visual_input_realize (input); localqueue = visual_event_queue_new (); while (running) { VisEventQueue *pluginqueue; VisEvent *ev; /* Handle all events */ display_drain_events (display, localqueue); pluginqueue = visual_plugin_get_eventqueue (visual_actor_get_plugin (actor)); while (visual_event_queue_poll_by_reference (localqueue, &ev)) { if (ev->type != VISUAL_EVENT_RESIZE) visual_event_queue_add (pluginqueue, ev); switch (ev->type) { case VISUAL_EVENT_RESIZE: video = display_get_video (display); visual_actor_set_video (actor, video); visual_actor_video_negotiate (actor, depth, FALSE, FALSE); break; case VISUAL_EVENT_MOUSEMOTION: break; case VISUAL_EVENT_MOUSEBUTTONDOWN: break; case VISUAL_EVENT_MOUSEBUTTONUP: break; case VISUAL_EVENT_KEYDOWN: switch (ev->event.keyboard.keysym.sym) { case VKEY_ESCAPE: running = FALSE; break; case VKEY_TAB: fullscreen = !fullscreen; display_set_fullscreen (display, fullscreen, TRUE); /* Resync video */ video = display_get_video (display); visual_actor_set_video (actor, video); visual_actor_video_negotiate (actor, depth, FALSE, FALSE); break; default: printf ("key: %c\n", ev->event.keyboard.keysym.sym); break; } break; case VISUAL_EVENT_KEYUP: break; case VISUAL_EVENT_QUIT: running = FALSE; break; case VISUAL_EVENT_VISIBILITY: visible = ev->event.visibility.is_visible; break; default: break; } } if (visible == FALSE) { visual_input_run (input); visual_time_usleep (10000); continue; } /* Do a run cycle */ visual_input_run (input); display_lock (display); visual_actor_run (actor, input->audio); display_unlock (display); display_update_all (display); display_fps_limit (display, 30); } /* Termination procedure */ display_set_fullscreen (display, FALSE, TRUE); display_close (display); visual_quit (); //visual_mem_alloc_profile (); printf ("Total frames: %d, average fps: %f\n", display_fps_total (display), display_fps_average (display)); return 0; }
static bool event_handler() { SDL_Event event; VisEventQueue *vevent; while( SDL_PollEvent( &event ) ) { vevent = visual_plugin_get_eventqueue( visual_actor_get_plugin( visual_bin_get_actor( Vis::bin ) ) ); switch( event.type ) { case SDL_KEYUP: visual_event_queue_add_keyboard( vevent, (VisKey)event.key.keysym.sym, event.key.keysym.mod, VISUAL_KEY_UP ); break; case SDL_KEYDOWN: visual_event_queue_add_keyboard (vevent, (VisKey)event.key.keysym.sym, event.key.keysym.mod, VISUAL_KEY_DOWN); switch( event.key.keysym.sym ) { //PLUGIN CONTROLS case SDLK_F11: case SDLK_TAB: SDL::toggleFullScreen(); break; case SDLK_ESCAPE: if( SDL::isFullScreen() ) SDL::toggleFullScreen(); break; case SDLK_LEFT: Vis::prevActor(); goto morph; case SDLK_RIGHT: Vis::nextActor(); morph: SDL::lock(); visual_bin_set_morph_by_name( Vis::bin, (char*)"alphablend" ); visual_bin_switch_actor_by_name( Vis::bin, (char*)Vis::plugin ); SDL::unlock(); SDL_WM_SetCaption( Vis::plugin, 0 ); break; default: ; } break; case SDL_VIDEORESIZE: Vis::resize( event.resize.w, event.resize.h ); break; case SDL_MOUSEMOTION: visual_event_queue_add_mousemotion (vevent, event.motion.x, event.motion.y); break; case SDL_MOUSEBUTTONDOWN: if (event.button.button == SDL_BUTTON_RIGHT) { SDL::toggleFullScreen(); break; } visual_event_queue_add_mousebutton (vevent, event.button.button, VISUAL_MOUSE_DOWN, 0, 0); break; case SDL_MOUSEBUTTONUP: visual_event_queue_add_mousebutton (vevent, event.button.button, VISUAL_MOUSE_UP, 0, 0); break; case SDL_QUIT: return false; default: ; } } return true; }
static void set_parameter_lv(void * data, const char * name, const bg_parameter_value_t * val) { int supported; lv_priv_t * priv; int index; int i_tmp; uint8_t r, g, b; char * tmp_string; VisParamEntry * param; VisListEntry * list_entry; VisColor * color; const bg_parameter_info_t * info; if(!name) return; priv = (lv_priv_t*)data; info = bg_parameter_find(priv->parameters, name); if(!info) return; /* This would crash if multi_parameters were supported */ index = info - priv->parameters; tmp_string = gavl_strdup(name); param = visual_param_entry_new(tmp_string); free(tmp_string); /* Menus have to be treated specially */ if(info->type == BG_PARAMETER_STRINGLIST) { if(!priv->widgets[index]) return; /* Get the selected index */ supported = 0; list_entry = NULL; while(visual_list_next(&VISUAL_UI_CHOICE(priv->widgets[index])->choices.choices, &list_entry)) { if(!strcmp(((VisUIChoiceEntry*)(list_entry->data))->name, val->val_str)) { visual_param_entry_set_from_param(param, ((VisUIChoiceEntry*)(list_entry->data))->value); supported = 1; break; } } } else { supported = 1; switch(priv->params[index]->type) { case VISUAL_PARAM_ENTRY_TYPE_NULL: /**< No parameter. */ supported = 0; break; case VISUAL_PARAM_ENTRY_TYPE_STRING: /**< String parameter. */ if(val->val_str) visual_param_entry_set_string(param, val->val_str); else supported = 0; break; case VISUAL_PARAM_ENTRY_TYPE_INTEGER: /**< Integer parameter. */ visual_param_entry_set_integer(param, val->val_i); break; case VISUAL_PARAM_ENTRY_TYPE_FLOAT: /**< Floating point parameter. */ visual_param_entry_set_float(param, val->val_f); break; case VISUAL_PARAM_ENTRY_TYPE_DOUBLE: /**< Double floating point parameter. */ visual_param_entry_set_double(param, val->val_f); break; case VISUAL_PARAM_ENTRY_TYPE_COLOR: /**< VisColor parameter. */ i_tmp = (int)(val->val_color[0] * 255.0 + 0.5); if(i_tmp < 0) i_tmp = 0; if(i_tmp > 255) i_tmp = 255; r = i_tmp; i_tmp = (int)(val->val_color[1] * 255.0 + 0.5); if(i_tmp < 0) i_tmp = 0; if(i_tmp > 255) i_tmp = 255; g = i_tmp; i_tmp = (int)(val->val_color[2] * 255.0 + 0.5); if(i_tmp < 0) i_tmp = 0; if(i_tmp > 255) i_tmp = 255; b = i_tmp; color = visual_color_new(); visual_color_set(color, r, g, b); visual_param_entry_set_color_by_color(param, color); visual_object_unref(VISUAL_OBJECT(color)); break; case VISUAL_PARAM_ENTRY_TYPE_PALETTE: /**< VisPalette parameter. */ case VISUAL_PARAM_ENTRY_TYPE_OBJECT: /**< VisObject parameter. */ case VISUAL_PARAM_ENTRY_TYPE_END: /**< List end, and used as terminator for VisParamEntry lists. */ supported = 0; break; } } if(supported) { visual_event_queue_add_param(visual_plugin_get_eventqueue(visual_actor_get_plugin(priv->actor)), param); } else visual_object_unref(VISUAL_OBJECT(param)); }
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; }
static bg_parameter_info_t * create_parameters(VisActor * actor, VisUIWidget *** widgets, VisParamEntry *** params_ret) { int num_parameters, i, index, supported; bg_parameter_info_t * ret; VisParamContainer * params; // VisHashmapChainEntry *entry; VisParamEntry *param_entry; VisListEntry * list_entry; VisUIWidget * widget; VisUIWidget * param_widget; params = visual_plugin_get_params(visual_actor_get_plugin(actor)); /* Count parameters */ num_parameters = 0; list_entry = NULL; while(visual_list_next(¶ms->entries, &list_entry)) num_parameters++; if(!num_parameters) return NULL; /* Create parameters */ ret = calloc(num_parameters+1, sizeof(*ret)); if(widgets) *widgets = calloc(num_parameters, sizeof(**widgets)); if(params_ret) *params_ret = calloc(num_parameters, sizeof(**params_ret)); list_entry = NULL; index = 0; widget = visual_plugin_get_userinterface(visual_actor_get_plugin(actor)); for(i = 0; i < num_parameters; i++) { visual_list_next(¶ms->entries, &list_entry); param_entry = list_entry->data; // param_entry = VISUAL_PARAMENTRY(entry->data); if(params_ret) (*params_ret)[index] = param_entry; supported = 1; if(widget) param_widget = check_widget(widget, param_entry->name, &ret[index]); else param_widget = NULL; if(!param_widget) { switch(param_entry->type) { case VISUAL_PARAM_ENTRY_TYPE_NULL: /**< No parameter. */ supported = 0; break; case VISUAL_PARAM_ENTRY_TYPE_STRING: /**< String parameter. */ ret[index].type = BG_PARAMETER_STRING; ret[index].val_default.val_str = gavl_strrep(ret[index].val_default.val_str, param_entry->string); break; case VISUAL_PARAM_ENTRY_TYPE_INTEGER: /**< Integer parameter. */ ret[index].type = BG_PARAMETER_INT; ret[index].flags |= BG_PARAMETER_SYNC; ret[index].val_default.val_i = param_entry->numeric.integer; break; case VISUAL_PARAM_ENTRY_TYPE_FLOAT: /**< Floating point parameter. */ ret[index].type = BG_PARAMETER_FLOAT; ret[index].flags |= BG_PARAMETER_SYNC; ret[index].val_default.val_f = param_entry->numeric.floating; break; case VISUAL_PARAM_ENTRY_TYPE_DOUBLE: /**< Double floating point parameter. */ ret[index].type = BG_PARAMETER_FLOAT; ret[index].flags |= BG_PARAMETER_SYNC; ret[index].val_default.val_f = param_entry->numeric.doubleflt; break; case VISUAL_PARAM_ENTRY_TYPE_COLOR: /**< VisColor parameter. */ ret[index].type = BG_PARAMETER_COLOR_RGB; ret[index].flags |= BG_PARAMETER_SYNC; ret[index].val_default.val_color[0] = (float)param_entry->color.r / 255.0; ret[index].val_default.val_color[1] = (float)param_entry->color.g / 255.0; ret[index].val_default.val_color[2] = (float)param_entry->color.b / 255.0; break; case VISUAL_PARAM_ENTRY_TYPE_PALETTE: /**< VisPalette parameter. */ case VISUAL_PARAM_ENTRY_TYPE_OBJECT: /**< VisObject parameter. */ case VISUAL_PARAM_ENTRY_TYPE_END: /**< List end, and used as terminator for VisParamEntry lists. */ supported = 0; break; } } if(widgets) (*widgets)[index] = param_widget; if(!supported) continue; ret[index].name = gavl_strdup(param_entry->name); ret[index].long_name = gavl_strdup(param_entry->name); index++; } return ret; }