static GstCaps *
gst_visual_gl_getcaps (GstPad * pad)
{
GstCaps *ret;
GstVisualGL *visual = GST_VISUAL_GL (gst_pad_get_parent (pad));
int depths;
if (!visual->actor) {
ret = gst_caps_copy (gst_pad_get_pad_template_caps (visual->srcpad));
goto beach;
}
ret = gst_caps_new_empty ();
depths = visual_actor_get_supported_depth (visual->actor);
if (depths < 0) {
/* FIXME: set an error */
goto beach;
}
if ((depths & VISUAL_VIDEO_DEPTH_GL) == 0) {
/* We don't handle non-GL plugins */
goto beach;
}
GST_DEBUG_OBJECT (visual, "libvisual-gl plugin supports depths %u (0x%04x)",
depths, depths);
/* only do GL output */
gst_caps_append (ret, gst_caps_from_string (GST_GL_VIDEO_CAPS));
beach:
GST_DEBUG_OBJECT (visual, "returning caps %" GST_PTR_FORMAT, ret);
gst_object_unref (visual);
return ret;
}
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;
}
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;
}
static GstCaps *
gst_visual_getcaps (GstPad * pad)
{
GstCaps *ret;
GstVisual *visual = GST_VISUAL (gst_pad_get_parent (pad));
int depths;
if (!visual->actor) {
ret = gst_caps_copy (gst_pad_get_pad_template_caps (visual->srcpad));
goto beach;
}
ret = gst_caps_new_empty ();
depths = visual_actor_get_supported_depth (visual->actor);
if (depths < 0) {
/* FIXME: set an error */
goto beach;
}
if (depths == VISUAL_VIDEO_DEPTH_GL) {
/* We can't handle GL only plugins */
goto beach;
}
GST_DEBUG_OBJECT (visual, "libvisual plugin supports depths %u (0x%04x)",
depths, depths);
/* if (depths & VISUAL_VIDEO_DEPTH_32BIT) Always supports 32bit output */
gst_caps_append (ret, gst_caps_from_string (GST_VIDEO_CAPS_xRGB_HOST_ENDIAN));
if (depths & VISUAL_VIDEO_DEPTH_24BIT) {
#if G_BYTE_ORDER == G_BIG_ENDIAN
gst_caps_append (ret, gst_caps_from_string (GST_VIDEO_CAPS_RGB));
#else
gst_caps_append (ret, gst_caps_from_string (GST_VIDEO_CAPS_BGR));
#endif
}
if (depths & VISUAL_VIDEO_DEPTH_16BIT) {
gst_caps_append (ret, gst_caps_from_string (GST_VIDEO_CAPS_RGB_16));
}
beach:
GST_DEBUG_OBJECT (visual, "returning caps %" GST_PTR_FORMAT, ret);
gst_object_unref (visual);
return ret;
}
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;
}
/**
* This function negotiates the VisActor with it's target video that is set by visual_actor_set_video.
* When needed it also sets up size fitting environment and depth transformation environment.
*
* The function has a few extra arguments that are mainly to be used from within internal code.
*
* This function needs to be called everytime there is a change within either the size or depth of
* the target video.
*
* The main method of calling this function is: "visual_actor_video_negotiate (actor, 0, FALSE, FALSE)"
*
* @see visual_actor_set_video
*
* @param actor Pointer to a VisActor that needs negotiation.
* @param rundepth An depth in the form of the VISUAL_VIDEO_DEPTH_* style when a depth is forced.
* This could be needed when for example a plugin has both a 8 bits and a 32 bits display method
* but while the target video is in 32 bits you still want to run the plugin in 8 bits. If this
* is desired the "forced" argument also needs to be set on TRUE.
* @param noevent When set on TRUE this does only renegotiate depth transformation environments. For example
* when the target display was running in 32 bits and switched to 8 bits while the plugin was already
* in 8 bits it doesn't need an events, which possibly reinitializes the plugin.
* @param forced This should be set if the rundepth argument is set, so it forces the plugin in a certain
* depth.
*
* @return VISUAL_OK on succes, -VISUAL_ERROR_ACTOR_NULL, -VISUAL_ERROR_PLUGIN_NULL, -VISUAL_ERROR_PLUGIN_REF_NULL,
* -VISUAL_ERROR_ACTOR_VIDEO_NULL or -VISUAL_ERROR_ACTOR_GL_NEGOTIATE on failure.
*/
int visual_actor_video_negotiate (VisActor *actor, int rundepth, int noevent, int forced)
{
int depthflag;
visual_log_return_val_if_fail (actor != NULL, -VISUAL_ERROR_ACTOR_NULL);
visual_log_return_val_if_fail (actor->plugin != NULL, -VISUAL_ERROR_PLUGIN_NULL);
visual_log_return_val_if_fail (actor->plugin->ref != NULL, -VISUAL_ERROR_PLUGIN_REF_NULL);
visual_log_return_val_if_fail (actor->video != NULL, -VISUAL_ERROR_ACTOR_VIDEO_NULL);
if (actor->transform != NULL) {
visual_object_unref (VISUAL_OBJECT (actor->transform));
actor->transform = NULL;
}
if (actor->fitting != NULL) {
visual_object_unref (VISUAL_OBJECT (actor->fitting));
actor->fitting = NULL;
}
if (actor->ditherpal != NULL) {
visual_object_unref (VISUAL_OBJECT (actor->ditherpal));
actor->ditherpal = NULL;
}
depthflag = visual_actor_get_supported_depth (actor);
visual_log (VISUAL_LOG_INFO, "negotiating plugin %s", actor->plugin->info->name);
/* Set up depth transformation enviroment */
if (visual_video_depth_is_supported (depthflag, actor->video->depth) != TRUE ||
(forced == TRUE && actor->video->depth != rundepth))
/* When the depth is not supported, or if we only switch the depth and not
* the size */
return negotiate_video_with_unsupported_depth (actor, rundepth, noevent, forced);
else
return negotiate_video (actor, noevent);
return -VISUAL_ERROR_IMPOSSIBLE;
}
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_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;
}
/** VisActor.actorGetSupportedDepth() */
JNIEXPORT jint JNICALL Java_org_libvisual_android_VisActor_actorGetSupportedDepth(JNIEnv * env, jobject obj, jint actor)
{
VisActor *a = (VisActor *) actor;
return visual_actor_get_supported_depth(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;
}
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;
}
