int pipeline_container_negotiate (LVAVSPipelineContainer *container, VisVideo *video) { VisListEntry *le = NULL; LVAVSPipelineElement *element; while ((element = visual_list_next (container->members, &le)) != NULL) { switch (element->type) { case LVAVS_PIPELINE_ELEMENT_TYPE_ACTOR: visual_actor_set_video (element->data.actor, video); visual_actor_video_negotiate (element->data.actor, VISUAL_VIDEO_DEPTH_NONE, FALSE, FALSE); break; case LVAVS_PIPELINE_ELEMENT_TYPE_TRANSFORM: visual_transform_set_video (element->data.transform, video); visual_transform_video_negotiate (element->data.transform); break; case LVAVS_PIPELINE_ELEMENT_TYPE_CONTAINER: pipeline_container_negotiate (LVAVS_PIPELINE_CONTAINER (element), video); break; default: break; } } return VISUAL_OK; }
static void size_changed(void * data, int width, int height) { lv_priv_t * priv; priv = (lv_priv_t*)data; visual_video_set_dimension(priv->video, width, height); visual_actor_set_video(priv->actor, priv->video); visual_actor_video_negotiate(priv->actor, 0, FALSE, FALSE); }
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; } }
static gboolean gst_visual_src_setcaps (GstPad * pad, GstCaps * caps) { GstVisual *visual = GST_VISUAL (gst_pad_get_parent (pad)); GstStructure *structure; gint depth, pitch; structure = gst_caps_get_structure (caps, 0); GST_DEBUG_OBJECT (visual, "src pad got caps %" GST_PTR_FORMAT, caps); if (!gst_structure_get_int (structure, "width", &visual->width)) goto error; if (!gst_structure_get_int (structure, "height", &visual->height)) goto error; if (!gst_structure_get_int (structure, "bpp", &depth)) goto error; if (!gst_structure_get_fraction (structure, "framerate", &visual->fps_n, &visual->fps_d)) goto error; visual_video_set_depth (visual->video, visual_video_depth_enum_from_value (depth)); visual_video_set_dimension (visual->video, visual->width, visual->height); pitch = GST_ROUND_UP_4 (visual->width * visual->video->bpp); visual_video_set_pitch (visual->video, pitch); visual_actor_video_negotiate (visual->actor, 0, FALSE, FALSE); /* precalc some values */ visual->outsize = visual->video->height * pitch; visual->spf = gst_util_uint64_scale_int (visual->rate, visual->fps_d, visual->fps_n); visual->duration = gst_util_uint64_scale_int (GST_SECOND, visual->fps_d, visual->fps_n); gst_object_unref (visual); return TRUE; /* ERRORS */ error: { GST_DEBUG_OBJECT (visual, "error parsing caps"); gst_object_unref (visual); return FALSE; } }
static int open_ov_lv(void * data, gavl_audio_format_t * audio_format, gavl_video_format_t * video_format) { int depths, depth; lv_priv_t * priv; priv = (lv_priv_t*)data; adjust_audio_format(audio_format); /* Get the depth */ depths = visual_actor_get_supported_depth(priv->actor); if(depths & VISUAL_VIDEO_DEPTH_32BIT) /**< 32 bits surface flag. */ { video_format->pixelformat = GAVL_BGR_32; depth = VISUAL_VIDEO_DEPTH_32BIT; } else if(depths & VISUAL_VIDEO_DEPTH_24BIT) /**< 24 bits surface flag. */ { video_format->pixelformat = GAVL_BGR_24; depth = VISUAL_VIDEO_DEPTH_24BIT; } else if(depths & VISUAL_VIDEO_DEPTH_16BIT) /**< 16 bits 5-6-5 surface flag. */ { video_format->pixelformat = GAVL_RGB_16; depth = VISUAL_VIDEO_DEPTH_16BIT; } else if(depths & VISUAL_VIDEO_DEPTH_8BIT) /**< 8 bits indexed surface flag. */ { video_format->pixelformat = GAVL_BGR_24; depth = VISUAL_VIDEO_DEPTH_24BIT; } else return 0; visual_video_set_depth(priv->video, depth); visual_video_set_dimension(priv->video, video_format->image_width, video_format->image_height); visual_actor_set_video(priv->actor, priv->video); visual_actor_video_negotiate(priv->actor, 0, FALSE, FALSE); return 1; }
static void actor_negotiate (GstGLDisplay * display, GstVisualGL * visual) { gint err = VISUAL_OK; err = visual_video_set_depth (visual->video, VISUAL_VIDEO_DEPTH_GL); if (err != VISUAL_OK) g_warning ("failed to visual_video_set_depth\n"); err = visual_video_set_dimension (visual->video, visual->width, visual->height); if (err != VISUAL_OK) g_warning ("failed to visual_video_set_dimension\n"); err = visual_actor_video_negotiate (visual->actor, 0, FALSE, FALSE); if (err != VISUAL_OK) g_warning ("failed to visual_actor_video_negotiate\n"); }
static int open_gl_lv(void * data, gavl_audio_format_t * audio_format, const char * window_id) { int width, height; lv_priv_t * priv; priv = (lv_priv_t*)data; visual_video_set_depth(priv->video, VISUAL_VIDEO_DEPTH_GL); adjust_audio_format(audio_format); gavl_audio_format_copy(&priv->audio_format, audio_format); bg_x11_window_set_gl(priv->win); visual_actor_set_video(priv->actor, priv->video); bg_x11_window_unset_gl(priv->win); /* Set the size changed callback after initializing the libvisual stuff */ bg_x11_window_set_callbacks(priv->win, &priv->window_callbacks); bg_x11_window_show(priv->win, 1); bg_x11_window_set_gl(priv->win); bg_x11_window_get_size(priv->win, &width, &height); /* We cannot use the size callback above since it's called before the actor is realized */ visual_video_set_dimension(priv->video, width, height); visual_actor_video_negotiate(priv->actor, 0, FALSE, FALSE); bg_x11_window_unset_gl(priv->win); 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; }
/* 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_run (VisBin *bin) { visual_log_return_val_if_fail (bin != NULL, -1); visual_log_return_val_if_fail (bin->actor != NULL, -1); visual_log_return_val_if_fail (bin->input != NULL, -1); visual_input_run (bin->input); /* If we have a direct switch, do this BEFORE we run the actor, * else we can get into trouble especially with GL, also when * switching away from a GL plugin this is needed */ if (bin->morphing == TRUE) { /* We realize here, because it doesn't realize * on switch, the reason for this is so that after a * switch call, especially in a managed bin the * depth can be requested and set, this is important * for openGL plugins, the realize method checks * for double realize itself so we don't have * to check this, it's a bit hacky */ visual_log_return_val_if_fail (bin->actmorph != NULL, -1); visual_log_return_val_if_fail (bin->actmorph->plugin != NULL, -1); if (bin->actmorph->plugin->realized == FALSE) { visual_actor_realize (bin->actmorph); if (bin->actmorphmanaged == TRUE) visual_actor_video_negotiate (bin->actmorph, bin->depthforced, FALSE, TRUE); else visual_actor_video_negotiate (bin->actmorph, 0, FALSE, FALSE); } /* When we've got multiple switch events without a sync we need * to realize the main actor as well */ visual_log_return_val_if_fail (bin->actor->plugin != NULL, -1); if (bin->actor->plugin->realized == FALSE) { visual_actor_realize (bin->actor); if (bin->managed == TRUE) visual_actor_video_negotiate (bin->actor, bin->depthforced, FALSE, TRUE); else visual_actor_video_negotiate (bin->actor, 0, FALSE, FALSE); } /* When the style is DIRECT or the context is GL we shouldn't try * to morph and instead finalize at once */ visual_log_return_val_if_fail (bin->actor->video != NULL, -1); if (bin->morphstyle == VISUAL_SWITCH_STYLE_DIRECT || bin->actor->video->depth == VISUAL_VIDEO_DEPTH_GL) { visual_bin_switch_finalize (bin); /* We can't start drawing yet, the client needs to catch up with * the depth change */ return 0; } } /* We realize here because in a managed bin the depth for openGL is * requested after the connect, thus we can realize there yet */ visual_actor_realize (bin->actor); visual_actor_run (bin->actor, bin->input->audio); if (bin->morphing == TRUE) { visual_log_return_val_if_fail (bin->actmorph != NULL, -1); visual_log_return_val_if_fail (bin->actmorph->video != NULL, -1); visual_log_return_val_if_fail (bin->actor->video != NULL, -1); if (bin->morphstyle == VISUAL_SWITCH_STYLE_MORPH && bin->actmorph->video->depth != VISUAL_VIDEO_DEPTH_GL && bin->actor->video->depth != VISUAL_VIDEO_DEPTH_GL) { visual_actor_run (bin->actmorph, bin->input->audio); if (bin->morph == NULL || bin->morph->plugin == NULL) { visual_bin_switch_finalize (bin); return 0; } /* Same goes for the morph, we realize it here for depth changes * (especially the openGL case */ visual_morph_realize (bin->morph); visual_morph_run (bin->morph, bin->input->audio, bin->actor->video, bin->actmorph->video); if (visual_morph_is_done (bin->morph) == TRUE) visual_bin_switch_finalize (bin); } else { /* visual_bin_switch_finalize (bin); */ } } return 0; }
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; }
int visual_bin_sync (VisBin *bin, int noevent) { VisVideo *video; VisVideo *actvideo; visual_log_return_val_if_fail (bin != NULL, -1); visual_log (VISUAL_LOG_DEBUG, "starting sync"); /* Sync the actor regarding morph */ if (bin->morphing == TRUE && bin->morphstyle == VISUAL_SWITCH_STYLE_MORPH && bin->actvideo->depth != VISUAL_VIDEO_DEPTH_GL && bin->depthfromGL != TRUE) { visual_morph_set_video (bin->morph, bin->actvideo); video = bin->privvid; if (video == NULL) { visual_log (VISUAL_LOG_DEBUG, "Private video data NULL"); return -1; } visual_video_free_buffer (video); visual_video_clone (video, bin->actvideo); visual_log (VISUAL_LOG_DEBUG, "pitches actvideo %d, new video %d", bin->actvideo->pitch, video->pitch); visual_log (VISUAL_LOG_DEBUG, "phase1 bin->privvid %p", bin->privvid); if (bin->actmorph->video->depth == VISUAL_VIDEO_DEPTH_GL) { visual_video_set_buffer (video, NULL); video = bin->actvideo; } else visual_video_allocate_buffer (video); visual_log (VISUAL_LOG_DEBUG, "phase2"); } else { video = bin->actvideo; if (video == NULL) { visual_log (VISUAL_LOG_DEBUG, "Actor video is NULL"); return -1; } visual_log (VISUAL_LOG_DEBUG, "setting new video from actvideo %d %d", video->depth, video->bpp); } /* Main actor */ /* visual_actor_realize (bin->actor); */ visual_actor_set_video (bin->actor, video); visual_log (VISUAL_LOG_DEBUG, "one last video pitch check %d depth old %d forcedmain %d noevent %d", video->pitch, bin->depthold, bin->depthforcedmain, noevent); if (bin->managed == TRUE) { if (bin->depthold == VISUAL_VIDEO_DEPTH_GL) visual_actor_video_negotiate (bin->actor, bin->depthforcedmain, FALSE, TRUE); else visual_actor_video_negotiate (bin->actor, bin->depthforcedmain, noevent, TRUE); } else { if (bin->depthold == VISUAL_VIDEO_DEPTH_GL) visual_actor_video_negotiate (bin->actor, 0, FALSE, TRUE); else visual_actor_video_negotiate (bin->actor, 0, noevent, FALSE); } visual_log (VISUAL_LOG_DEBUG, "pitch after main actor negotiate %d", video->pitch); /* Morphing actor */ if (bin->actmorphmanaged == TRUE && bin->morphing == TRUE && bin->morphstyle == VISUAL_SWITCH_STYLE_MORPH) { actvideo = bin->actmorphvideo; if (actvideo == NULL) { visual_log (VISUAL_LOG_DEBUG, "Morph video is NULL"); return -1; } visual_video_free_buffer (actvideo); visual_video_clone (actvideo, video); if (bin->actor->video->depth != VISUAL_VIDEO_DEPTH_GL) visual_video_allocate_buffer (actvideo); visual_actor_realize (bin->actmorph); visual_log (VISUAL_LOG_DEBUG, "phase3 pitch of real framebuffer %d", bin->actvideo->pitch); if (bin->actmorphmanaged == TRUE) visual_actor_video_negotiate (bin->actmorph, bin->depthforced, FALSE, TRUE); else visual_actor_video_negotiate (bin->actmorph, 0, FALSE, FALSE); } visual_log (VISUAL_LOG_DEBUG, "end sync function"); return 0; }
/** VisActor.actorVideoNegotiate() */ JNIEXPORT jint JNICALL Java_org_libvisual_android_VisActor_actorVideoNegotiate(JNIEnv * env, jobject obj, jint actor, jint rundepth, jboolean noevent, jboolean forced) { VisActor *a = (VisActor *) actor; return visual_actor_video_negotiate(a, rundepth, noevent, forced); }
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; }
/* 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 (); }