bool Actor::video_negotiate (VisVideoDepth run_depth, bool noevent, bool forced) { auto output_width = m_impl->video->get_width (); auto output_height = m_impl->video->get_height (); auto output_depth = m_impl->video->get_depth (); // Ask actor for preferred rendering dimensions int run_width = output_width; int run_height = output_height; m_impl->get_actor_plugin ()->requisition (m_impl->plugin, &run_width, &run_height); // Check to make sure requested run depth is supported. If not, pick the highest. auto supported_depths = get_supported_depths (); m_impl->run_depth = forced ? run_depth : visual_video_depth_get_highest_nogl (supported_depths); if (!visual_video_depth_is_supported (supported_depths, m_impl->run_depth)) { m_impl->run_depth = visual_video_depth_get_highest_nogl (supported_depths); } // Configure proxy videos to convert rendering m_impl->to_scale.reset (); m_impl->to_convert.reset (); visual_log (VISUAL_LOG_DEBUG, "Setting up any necessary video conversions.."); if (output_depth != VISUAL_VIDEO_DEPTH_GL) { // Configure any necessary depth conversion if (m_impl->run_depth != output_depth) { visual_log (VISUAL_LOG_DEBUG, "Setting up depth conversion: %s -> %s", visual_video_depth_name (m_impl->run_depth), visual_video_depth_name (output_depth)); m_impl->to_convert = Video::create (output_width, output_height, m_impl->run_depth); } // Configure any necessary scaling if (run_width != output_width || run_height != output_height) { visual_log (VISUAL_LOG_DEBUG, "Setting up scaling: (%dx%d) -> (%dx%d)", run_width, run_height, output_width, output_height); m_impl->to_scale = Video::create (run_width, run_height, output_depth); } } else { visual_log (VISUAL_LOG_DEBUG, "Conversions skipped in OpenGL rendering mode"); } // FIXME: This should be moved into the if block above. It's out // here because plugins depend on this to receive information // about initial dimensions if (!noevent) { visual_event_queue_add (visual_plugin_get_event_queue (m_impl->plugin), visual_event_new_resize (run_width, run_height)); } return true; }
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 visual_transform_video_negotiate (VisTransform *transform) { int depthflag; visual_return_val_if_fail (transform != NULL, -VISUAL_ERROR_TRANSFORM_NULL); visual_return_val_if_fail (transform->plugin != NULL, -VISUAL_ERROR_PLUGIN_NULL); depthflag = visual_transform_get_supported_depth (transform); if (!visual_video_depth_is_supported (depthflag, transform->video->depth)) return -VISUAL_ERROR_TRANSFORM_NEGOTIATE; visual_event_queue_add (transform->plugin->eventqueue, visual_event_new_resize (transform->video->width, transform->video->height)); visual_plugin_events_pump (transform->plugin); return -VISUAL_OK; }
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; }
void Actor::run (Audio const& audio) { visual_return_if_fail (m_impl->video); auto actor_plugin = m_impl->get_actor_plugin (); if (!actor_plugin) { visual_log (VISUAL_LOG_ERROR, "The given actor does not reference any actor plugin"); return; } auto plugin = get_plugin (); /* Songinfo handling */ if (!visual_songinfo_compare (&m_impl->songcompare, actor_plugin->songinfo) || m_impl->songcompare.get_elapsed () != actor_plugin->songinfo->get_elapsed ()) { actor_plugin->songinfo->mark (); visual_event_queue_add (visual_plugin_get_event_queue (plugin), visual_event_new_newsong (actor_plugin->songinfo)); visual_songinfo_copy (&m_impl->songcompare, actor_plugin->songinfo); } // Get plugin to process all events visual_plugin_events_pump (m_impl->plugin); auto const& video = m_impl->video; auto const& to_convert = m_impl->to_convert; auto const& to_scale = m_impl->to_scale; if (video->get_depth () != VISUAL_VIDEO_DEPTH_GL) { auto palette = get_palette (); if (to_convert) { // Have depth conversion // Setup any palette if (palette) { to_convert->set_palette (*palette); } // Render first actor_plugin->render (m_impl->plugin, to_convert.get (), const_cast<Audio*> (&audio)); if (to_scale) { // Convert depth, then scale to_scale->convert_depth (to_convert); video->scale (to_scale, VISUAL_VIDEO_SCALE_NEAREST); } else { // Convert depth only video->convert_depth (to_convert); } } else { // No depth conversion if (to_scale) { // Setup any palette if (palette) { to_scale->set_palette (*palette); } // Render, then scale actor_plugin->render (m_impl->plugin, to_scale.get (), const_cast<Audio*> (&audio)); video->scale (to_scale, VISUAL_VIDEO_SCALE_NEAREST); } else { // Setup any palette if (palette) { video->set_palette (*palette); } // Render directly to video target actor_plugin->render (m_impl->plugin, video.get (), const_cast<Audio*> (&audio)); } } } else { // Render directly to video target (OpenGL) actor_plugin->render (m_impl->plugin, video.get (), const_cast<Audio*> (&audio)); } }