/** 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; }
static gboolean gst_visual_setup (GstAudioVisualizer * bscope) { GstVisual *visual = GST_VISUAL (bscope); gint depth; gst_visual_clear_actors (visual); /* FIXME: we need to know how many bits we actually have in memory */ depth = bscope->vinfo.finfo->pixel_stride[0]; if (bscope->vinfo.finfo->bits >= 8) { depth *= 8; } visual->actor = visual_actor_new (GST_VISUAL_GET_CLASS (visual)->plugin->info->plugname); visual->video = visual_video_new (); visual->audio = visual_audio_new (); /* can't have a play without actors */ if (!visual->actor || !visual->video) goto no_actors; if (visual_actor_realize (visual->actor) != 0) goto no_realize; visual_actor_set_video (visual->actor, visual->video); visual_video_set_depth (visual->video, visual_video_depth_enum_from_value (depth)); visual_video_set_dimension (visual->video, GST_VIDEO_INFO_WIDTH (&bscope->vinfo), GST_VIDEO_INFO_HEIGHT (&bscope->vinfo)); visual_actor_video_negotiate (visual->actor, 0, FALSE, FALSE); GST_DEBUG_OBJECT (visual, "WxH: %dx%d, bpp: %d, depth: %d", GST_VIDEO_INFO_WIDTH (&bscope->vinfo), GST_VIDEO_INFO_HEIGHT (&bscope->vinfo), visual->video->bpp, depth); return TRUE; /* ERRORS */ no_actors: { GST_ELEMENT_ERROR (visual, LIBRARY, INIT, (NULL), ("could not create actors")); gst_visual_clear_actors (visual); return FALSE; } no_realize: { GST_ELEMENT_ERROR (visual, LIBRARY, INIT, (NULL), ("could not realize actor")); gst_visual_clear_actors (visual); return FALSE; } }
int visual_bin_connect_by_names (VisBin *bin, char *actname, char *inname) { VisActor *actor; VisInput *input; int depthflag; int depth; visual_log_return_val_if_fail (bin != NULL, -1); /* Create the actor */ actor = visual_actor_new (actname); visual_log_return_val_if_fail (actor != NULL, -1); /* Check and set required depth */ depthflag = visual_actor_get_supported_depth (actor); /* GL plugin, and ONLY a GL plugin */ if (depthflag == VISUAL_VIDEO_DEPTH_GL) visual_bin_set_depth (bin, VISUAL_VIDEO_DEPTH_GL); else { depth = bin_get_depth_using_preferred (bin, depthflag); /* Is supported within bin natively */ if ((bin->depthflag & depth) > 0) { visual_bin_set_depth (bin, depth); } else { /* Not supported by the bin, taking the highest depth from the bin */ visual_bin_set_depth (bin, visual_video_depth_get_highest_nogl (bin->depthflag)); } } /* Initialize the managed depth */ bin->depthforcedmain = bin->depth; /* Create the input */ input = visual_input_new (inname); visual_log_return_val_if_fail (input != NULL, -1); /* Connect */ visual_bin_connect (bin, actor, input); bin->managed = TRUE; bin->inputmanaged = TRUE; return 0; }
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; }
/* Internal functions */ int pipeline_from_preset (LVAVSPipelineContainer *container, LVAVSPresetContainer *presetcont) { VisListEntry *le = NULL; LVAVSPresetElement *pelem; LVAVSPipelineElement *element; LVAVSPipelineContainer *cont; VisPluginRef *ref; LVAVSPipeline *pipeline = LVAVS_PIPELINE_ELEMENT(container)->pipeline; while ((pelem = visual_list_next (presetcont->members, &le)) != NULL) { switch (pelem->type) { case LVAVS_PRESET_ELEMENT_TYPE_PLUGIN: ref = visual_plugin_find (visual_plugin_get_registry (), pelem->element_name); if (ref == NULL) { visual_log (VISUAL_LOG_CRITICAL, "Requested plugin %s not in registry", pelem->element_name); break; } if (ref->info == NULL) { visual_log (VISUAL_LOG_CRITICAL, "Could not get VisPluginInfo for %s", pelem->element_name); break; } /* FIXME fix libvisual type lookup and use the functions here */ if (strcmp (ref->info->type, VISUAL_PLUGIN_TYPE_ACTOR) == 0) { element = lvavs_pipeline_element_new (LVAVS_PIPELINE_ELEMENT_TYPE_ACTOR); element->data.actor = visual_actor_new (pelem->element_name); visual_object_set_private(VISUAL_OBJECT(element->data.actor->plugin), pipeline); } else if (strcmp (ref->info->type, VISUAL_PLUGIN_TYPE_MORPH) == 0) { element = lvavs_pipeline_element_new (LVAVS_PIPELINE_ELEMENT_TYPE_MORPH); element->data.morph = visual_morph_new (pelem->element_name); visual_object_set_private(VISUAL_OBJECT(element->data.morph->plugin), pipeline); } else if (strcmp (ref->info->type, VISUAL_PLUGIN_TYPE_TRANSFORM) == 0) { element = lvavs_pipeline_element_new (LVAVS_PIPELINE_ELEMENT_TYPE_TRANSFORM); element->data.transform = visual_transform_new (pelem->element_name); visual_object_set_private(VISUAL_OBJECT(element->data.transform->plugin), pipeline); } else { printf("uknown type '%s' '%s'\n", ref->info->type, ref->info->name); } if (pelem->pcont != NULL) { element->params = visual_param_container_new (); visual_param_container_copy (element->params, pelem->pcont); } element->pipeline = LVAVS_PIPELINE_ELEMENT (container)->pipeline; visual_list_add (container->members, element); break; case LVAVS_PRESET_ELEMENT_TYPE_CONTAINER: cont = lvavs_pipeline_container_new (); LVAVS_PIPELINE_ELEMENT(cont)->params = LVAVS_PIPELINE_ELEMENT(container)->params; LVAVS_PIPELINE_ELEMENT(cont)->pipeline = LVAVS_PIPELINE_ELEMENT(container)->pipeline; visual_list_add (container->members, cont); pipeline_from_preset (cont, LVAVS_PRESET_CONTAINER (pelem)); break; case LVAVS_PRESET_ELEMENT_TYPE_RENDERSTATE: break; case LVAVS_PRESET_ELEMENT_TYPE_COMMENT: break; case LVAVS_PRESET_ELEMENT_TYPE_BPM: break; case LVAVS_PRESET_ELEMENT_TYPE_STACK: break; default: visual_log (VISUAL_LOG_CRITICAL, "Invalid LVAVSPresetElementType in LVAVSPresetElement"); break; } } return VISUAL_OK; }
/* Main stuff */ int main (int argc, char *argv[]) { int width = 1000, height = 600; int i, j; int freeze = 0; int depthflag = 0; int alpha = 190; int xoff = 0, yoff = -90; int sxsize = 1000; int sysize = 700; int interpol = VISUAL_VIDEO_SCALE_NEAREST; int frames = 0; VisTime start, end; bpp = 4; sdl_init (width, height); scrbuf = malloc (screen->pitch * screen->h); memset (scrbuf, 0, screen->pitch * screen->h); SDL_Event event; visual_init (&argc, &argv); if (argc > 1) actor = visual_actor_new (argv[1]); else actor = visual_actor_new ("corona"); visual_actor_realize (actor); video = visual_video_new (); if (argc > 2) video = visual_bitmap_load_new_video (argv[2]); else video = visual_bitmap_load_new_video ("bg.bmp"); actvid = visual_video_new (); visual_actor_set_video (actor, actvid); visual_video_set_depth (actvid, visual_video_depth_get_highest (visual_actor_get_supported_depth (actor))); visual_video_set_dimension (actvid, width, height); visual_video_allocate_buffer (actvid); visual_actor_video_negotiate (actor, 0, FALSE, FALSE); video32 = visual_video_new (); visual_video_set_depth (video32, VISUAL_VIDEO_DEPTH_32BIT); visual_video_set_dimension (video32, video->width, video->height); visual_video_allocate_buffer (video32); scalevid = visual_video_new (); visual_video_set_depth (scalevid, VISUAL_VIDEO_DEPTH_32BIT); visual_video_set_dimension (scalevid, sxsize, sysize); visual_video_allocate_buffer (scalevid); sdlvid = visual_video_new (); visual_video_set_depth (sdlvid, VISUAL_VIDEO_DEPTH_32BIT); visual_video_set_dimension (sdlvid, screen->w, screen->h); visual_video_set_pitch (sdlvid, screen->pitch); visual_video_set_buffer (sdlvid, scrbuf); input = visual_input_new ("xmms2"); visual_input_realize (input); SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); visual_time_get (&start); while (1) { visual_input_run (input); visual_actor_run (actor, input->audio); /* place on screen */ // visual_video_blit_overlay (sdlvid, video, 0, 0, FALSE); if (sxsize < 0) sxsize = 0; if (sysize < 0) sysize = 0; if (sxsize != scalevid->width || sysize != scalevid->height) { visual_video_set_dimension (scalevid, sxsize, sysize); visual_video_allocate_buffer (scalevid); } visual_video_depth_transform (video32, video); // visual_video_alpha_fill (sdlvid, 0); // visual_video_alpha_fill (video32, alpha); // visual_video_alpha_color (video32, 0, 0, 0, 255); do_alpha (video32, alpha); visual_video_scale (scalevid, video32, interpol); visual_video_blit_overlay (sdlvid, actvid, 0, 0, FALSE); visual_video_blit_overlay (sdlvid, scalevid, xoff, yoff, TRUE); sdl_draw_buf (); frames++; while (SDL_PollEvent (&event)) { switch (event.type) { case SDL_KEYDOWN: switch (event.key.keysym.sym) { case SDLK_F11: SDL_WM_ToggleFullScreen (screen); break; case SDLK_UP: yoff -= 10; break; case SDLK_DOWN: yoff += 10; break; case SDLK_LEFT: xoff -= 10; break; case SDLK_RIGHT: xoff += 10; break; case SDLK_q: sysize -= 10; break; case SDLK_a: sysize += 10; break; case SDLK_z: sxsize -= 10; break; case SDLK_x: sxsize += 10; break; case SDLK_i: if (interpol == VISUAL_VIDEO_SCALE_NEAREST) interpol = VISUAL_VIDEO_SCALE_BILINEAR; else interpol = VISUAL_VIDEO_SCALE_NEAREST; break; case SDLK_o: alpha -= 8; if (alpha < 0) alpha = 0; break; case SDLK_p: alpha += 8; if (alpha > 255) alpha = 255; break; case SDLK_ESCAPE: goto out; break; } break; case SDL_VIDEORESIZE: sdl_size_request (event.resize.w, event.resize.h); break; case SDL_QUIT: goto out; break; } } } out: visual_time_get (&end); VisTime diff; visual_time_difference (&diff, &start, &end); printf ("Ran: %d:%d, drawn %d frames\n", diff.tv_sec, diff.tv_usec, frames); SDL_Quit (); }
int visual_bin_switch_actor_by_name (VisBin *bin, char *actname) { VisActor *actor; VisVideo *video; int depthflag; int depth; visual_log_return_val_if_fail (bin != NULL, -1); visual_log_return_val_if_fail (actname != NULL, -1); visual_log (VISUAL_LOG_DEBUG, "switching to a new actor: %s, old actor: %s", actname, bin->actor->plugin->info->name); /* Destroy if there already is a managed one */ if (bin->actmorphmanaged == TRUE) { if (bin->actmorph != NULL) { visual_object_unref (VISUAL_OBJECT (bin->actmorph)); if (bin->actmorphvideo != NULL) visual_object_unref (VISUAL_OBJECT (bin->actmorphvideo)); } } /* Create a new managed actor */ actor = visual_actor_new (actname); visual_log_return_val_if_fail (actor != NULL, -1); video = visual_video_new (); visual_video_clone (video, bin->actvideo); depthflag = visual_actor_get_supported_depth (actor); if (visual_video_depth_is_supported (depthflag, VISUAL_VIDEO_DEPTH_GL) == TRUE) { visual_log (VISUAL_LOG_INFO, _("Switching to Gl mode")); bin->depthforced = VISUAL_VIDEO_DEPTH_GL; bin->depthforcedmain = VISUAL_VIDEO_DEPTH_GL; visual_video_set_depth (video, VISUAL_VIDEO_DEPTH_GL); visual_bin_set_depth (bin, VISUAL_VIDEO_DEPTH_GL); bin->depthchanged = TRUE; } else { visual_log (VISUAL_LOG_INFO, _("Switching away from Gl mode -- or non Gl switch")); /* Switching from GL */ depth = bin_get_depth_using_preferred (bin, depthflag); fix_depth_with_bin (bin, video, depth); visual_log (VISUAL_LOG_DEBUG, "after depth fixating"); /* After a depth change, the pitch value needs an update from the client * if it's different from width * bpp, after a visual_bin_sync * the issues are fixed again */ visual_log (VISUAL_LOG_INFO, _("video depth (from fixate): %d"), video->depth); /* FIXME check if there are any unneeded depth transform environments and drop these */ visual_log (VISUAL_LOG_DEBUG, "checking if we need to drop something: depthforcedmain: %d actvideo->depth %d", bin->depthforcedmain, bin->actvideo->depth); /* Drop a transformation environment when not needed */ if (bin->depthforcedmain != bin->actvideo->depth) { visual_actor_video_negotiate (bin->actor, bin->depthforcedmain, TRUE, TRUE); visual_log (VISUAL_LOG_DEBUG, "[[[[optionally a bogus transform environment, dropping]]]]\n"); } if (bin->actvideo->depth > video->depth && bin->actvideo->depth != VISUAL_VIDEO_DEPTH_GL && bin->morphstyle == VISUAL_SWITCH_STYLE_MORPH) { visual_log (VISUAL_LOG_INFO, _("old depth is higher, video depth %d, depth %d, bin depth %d"), video->depth, depth, bin->depth); bin->depthforced = depth; bin->depthforcedmain = bin->depth; visual_bin_set_depth (bin, bin->actvideo->depth); visual_video_set_depth (video, bin->actvideo->depth); } else if (bin->actvideo->depth != VISUAL_VIDEO_DEPTH_GL) { visual_log (VISUAL_LOG_INFO, _("new depth is higher, or equal: video depth %d, depth %d bin depth %d"), video->depth, depth, bin->depth); visual_log (VISUAL_LOG_DEBUG, "depths i can locate: actvideo: %d bin: %d bin-old: %d", bin->actvideo->depth, bin->depth, bin->depthold); bin->depthforced = video->depth; bin->depthforcedmain = bin->depth; visual_log (VISUAL_LOG_DEBUG, "depthforcedmain in switch by name: %d", bin->depthforcedmain); visual_log (VISUAL_LOG_DEBUG, "visual_bin_set_depth %d", video->depth); visual_bin_set_depth (bin, video->depth); } else { /* Don't force ourself into a GL depth, seen we do a direct * switch in the run */ bin->depthforced = video->depth; bin->depthforcedmain = video->depth; visual_log (VISUAL_LOG_INFO, _("Switching from Gl TO framebuffer for real, framebuffer depth: %d"), video->depth); } visual_log (VISUAL_LOG_INFO, _("Target depth selected: %d"), depth); visual_video_set_dimension (video, video->width, video->height); visual_log (VISUAL_LOG_INFO, _("Switch to new pitch: %d"), bin->actvideo->pitch); if (bin->actvideo->depth != VISUAL_VIDEO_DEPTH_GL) visual_video_set_pitch (video, bin->actvideo->pitch); visual_log (VISUAL_LOG_DEBUG, "before allocating buffer"); visual_video_allocate_buffer (video); visual_log (VISUAL_LOG_DEBUG, "after allocating buffer"); } visual_log (VISUAL_LOG_INFO, _("video pitch of that what connects to the new actor %d"), video->pitch); visual_actor_set_video (actor, video); bin->actmorphvideo = video; bin->actmorphmanaged = TRUE; visual_log (VISUAL_LOG_INFO, _("switching... ******************************************")); visual_bin_switch_actor (bin, actor); visual_log (VISUAL_LOG_INFO, _("end switch actor by name function ******************")); return 0; }
static GstStateChangeReturn gst_visual_change_state (GstElement * element, GstStateChange transition) { GstVisual *visual = GST_VISUAL (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: visual->actor = visual_actor_new (GST_VISUAL_GET_CLASS (visual)->plugin-> info->plugname); visual->video = visual_video_new (); visual->audio = visual_audio_new (); /* can't have a play without actors */ if (!visual->actor || !visual->video) goto no_actors; if (visual_actor_realize (visual->actor) != 0) goto no_realize; visual_actor_set_video (visual->actor, visual->video); break; case GST_STATE_CHANGE_READY_TO_PAUSED: gst_visual_reset (visual); break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: break; case GST_STATE_CHANGE_READY_TO_NULL: gst_visual_clear_actors (visual); break; default: break; } return ret; /* ERRORS */ no_actors: { GST_ELEMENT_ERROR (visual, LIBRARY, INIT, (NULL), ("could not create actors")); gst_visual_clear_actors (visual); return GST_STATE_CHANGE_FAILURE; } no_realize: { GST_ELEMENT_ERROR (visual, LIBRARY, INIT, (NULL), ("could not realize actor")); gst_visual_clear_actors (visual); return GST_STATE_CHANGE_FAILURE; } }
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 GstStateChangeReturn gst_visual_gl_change_state (GstElement * element, GstStateChange transition) { GstVisualGL *visual = GST_VISUAL_GL (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: { GstElement *parent = GST_ELEMENT (gst_element_get_parent (visual)); GstStructure *structure = NULL; GstQuery *query = NULL; gboolean isPerformed = FALSE; gchar *name; if (!parent) { GST_ELEMENT_ERROR (visual, CORE, STATE_CHANGE, (NULL), ("A parent bin is required")); return FALSE; } name = gst_element_get_name (visual); structure = gst_structure_new (name, NULL); query = gst_query_new_application (GST_QUERY_CUSTOM, structure); g_free (name); isPerformed = gst_element_query (parent, query); if (isPerformed) { const GValue *id_value = gst_structure_get_value (structure, "gstgldisplay"); if (G_VALUE_HOLDS_POINTER (id_value)) /* at least one gl element is after in our gl chain */ visual->display = gst_object_ref (GST_GL_DISPLAY (g_value_get_pointer (id_value))); else { /* this gl filter is a sink in terms of the gl chain */ visual->display = gst_gl_display_new (); gst_gl_display_create_context (visual->display, 0); //TODO visual->external_gl_context); } gst_visual_gl_reset (visual); visual->actor = visual_actor_new (GST_VISUAL_GL_GET_CLASS (visual)->plugin->info-> plugname); visual->video = visual_video_new (); visual->audio = visual_audio_new (); if (!visual->actor || !visual->video) goto actor_setup_failed; gst_gl_display_thread_add (visual->display, (GstGLDisplayThreadFunc) actor_setup, visual); if (visual->actor_setup_result != 0) goto actor_setup_failed; else visual_actor_set_video (visual->actor, visual->video); } gst_query_unref (query); gst_object_unref (GST_OBJECT (parent)); if (!isPerformed) return GST_STATE_CHANGE_FAILURE; } break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: { if (visual->fbo) { gst_gl_display_del_fbo (visual->display, visual->fbo, visual->depthbuffer); visual->fbo = 0; visual->depthbuffer = 0; } if (visual->midtexture) { gst_gl_display_del_texture (visual->display, visual->midtexture, visual->width, visual->height); visual->midtexture = 0; } if (visual->display) { gst_object_unref (visual->display); visual->display = NULL; } gst_visual_gl_clear_actors (visual); } break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; /* ERRORS */ actor_setup_failed: { GST_ELEMENT_ERROR (visual, LIBRARY, INIT, (NULL), ("could not set up actor")); gst_visual_gl_clear_actors (visual); return GST_STATE_CHANGE_FAILURE; } }
/* Main stuff */ int main (int argc, char *argv[]) { int width = 1000, height = 600; int i, j; int freeze = 0; int depthflag = 0; int alpha = 128; bpp = 4; sdl_init (width, height); scrbuf = malloc (screen->pitch * screen->h); memset (scrbuf, 0, screen->pitch * screen->h); SDL_Event event; visual_init (&argc, &argv); if (argc > 1) actor = visual_actor_new (argv[1]); else actor = visual_actor_new ("G-Force"); visual_actor_realize (actor); video = visual_video_new (); visual_actor_set_video (actor, video); visual_video_set_depth (video, VISUAL_VIDEO_DEPTH_32BIT); visual_video_set_dimension (video, 256, 256); visual_video_allocate_buffer (video); visual_actor_video_negotiate (actor, 0, FALSE, FALSE); scalevid = visual_video_new (); visual_video_set_depth (scalevid, VISUAL_VIDEO_DEPTH_32BIT); visual_video_set_dimension (scalevid, 300, 400); visual_video_allocate_buffer (scalevid); sdlvid = visual_video_new (); visual_video_set_depth (sdlvid, VISUAL_VIDEO_DEPTH_32BIT); visual_video_set_dimension (sdlvid, screen->w, screen->h); visual_video_set_pitch (sdlvid, screen->pitch); visual_video_set_buffer (sdlvid, scrbuf); input = visual_input_new ("alsa"); visual_input_realize (input); while (1) { visual_input_run (input); visual_actor_run (actor, input->audio); /* place on screen */ visual_video_blit_overlay (sdlvid, video, 0, 0, FALSE); visual_video_set_palette (scalevid, visual_actor_get_palette (actor)); visual_video_scale (scalevid, video, VISUAL_VIDEO_SCALE_BILINEAR); visual_video_blit_overlay (sdlvid, scalevid, 256, 0, FALSE); sdl_draw_buf (); usleep (5000); while (SDL_PollEvent (&event)) { switch (event.type) { case SDL_KEYDOWN: switch (event.key.keysym.sym) { case SDLK_F11: sdl_fullscreen_toggle (); break; case SDLK_q: alpha -= 8; if (alpha < 0) alpha = 0; break; case SDLK_a: alpha += 8; if (alpha > 255) alpha = 255; break; case SDLK_ESCAPE: goto out; break; } break; case SDL_VIDEORESIZE: sdl_size_request (event.resize.w, event.resize.h); break; case SDL_QUIT: goto out; break; } } } out: SDL_Quit (); }
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; }