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;
}
int visual_bin_switch_finalize (VisBin *bin)
{
int depthflag;
visual_log_return_val_if_fail (bin != NULL, -1);
visual_log (VISUAL_LOG_DEBUG, "Entering...");
if (bin->managed == TRUE)
visual_object_unref (VISUAL_OBJECT (bin->actor));
/* Copy over the depth to be sure, and for GL plugins */
/* bin->actvideo->depth = bin->actmorphvideo->depth;
visual_video_set_depth (bin->actvideo, bin->actmorphvideo->depth); */
if (bin->actmorphmanaged == TRUE) {
visual_object_unref (VISUAL_OBJECT (bin->actmorphvideo));
bin->actmorphvideo = NULL;
}
if (bin->privvid != NULL) {
visual_object_unref (VISUAL_OBJECT (bin->privvid));
bin->privvid = NULL;
}
bin->actor = bin->actmorph;
bin->actmorph = NULL;
visual_actor_set_video (bin->actor, bin->actvideo);
bin->morphing = FALSE;
if (bin->morphmanaged == TRUE) {
visual_object_unref (VISUAL_OBJECT (bin->morph));
bin->morph = NULL;
}
visual_log (VISUAL_LOG_DEBUG, " - in finalize - fscking depth from actvideo: %d %d", bin->actvideo->depth, bin->actvideo->bpp);
/* visual_bin_set_depth (bin, bin->actvideo->depth); */
depthflag = visual_actor_get_supported_depth (bin->actor);
fix_depth_with_bin (bin, bin->actvideo, bin_get_depth_using_preferred (bin, depthflag));
visual_bin_set_depth (bin, bin->actvideo->depth);
bin->depthforcedmain = bin->actvideo->depth;
visual_log (VISUAL_LOG_DEBUG, "bin->depthforcedmain in finalize %d", bin->depthforcedmain);
/* FIXME replace with a depth fixer */
if (bin->depthchanged == TRUE) {
visual_log (VISUAL_LOG_INFO, _("negotiate without event"));
visual_actor_video_negotiate (bin->actor, bin->depthforcedmain, TRUE, TRUE);
visual_log (VISUAL_LOG_INFO, _("end negotiate without event"));
/* visual_bin_sync (bin); */
}
visual_log (VISUAL_LOG_DEBUG, "Leaving...");
return 0;
}
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;
}
/** VisBin.setDepth() */
JNIEXPORT void JNICALL Java_org_libvisual_android_VisBin_binSetDepth(JNIEnv * env, jobject obj, jint bin, jint depth)
{
VisBin *b = (VisBin *) bin;
visual_bin_set_depth(b, depth);
}
/** VisBin.setDepth() */
JNIEXPORT void JNICALL Java_org_libvisual_android_VisBin_binSetDepth(JNIEnv * env, jobject obj, jobject bin, jint depth)
{
VisBin *b = getObjectFromCPtr<VisBin *>(env, bin);
visual_bin_set_depth(b, depth);
}
