int main (int argc, char **argv) { VisVideo *dest, *src; int i; visual_init (&argc, &argv); dest = visual_video_new (); visual_video_set_depth (dest, DEPTH); visual_video_set_dimension (dest, 640, 400); visual_video_allocate_buffer (dest); src = visual_video_new (); visual_video_set_depth (src, DEPTH); visual_video_set_dimension (src, 320, 200); visual_video_allocate_buffer (src); for (i = 0; i < TIMES; i++) visual_video_scale (dest, src, INTERPOL); printf ("Scale bench overlay %d times, depth %d, interpol %d\n", TIMES, DEPTH, INTERPOL); return EXIT_SUCCESS; }
int main (int argc, char **argv) { float rate = 0.0; VisMorph *morph; VisAudio audio; VisVideo *dest, *src1, *src2; int i; visual_init (&argc, &argv); if (argc < 2) morph = visual_morph_new ("alphablend"); else morph = visual_morph_new (argv[1]); visual_morph_realize (morph); dest = visual_video_new (); visual_video_set_depth (dest, DEPTH); visual_video_set_dimension (dest, 640, 400); visual_video_allocate_buffer (dest); src1 = visual_video_new (); src2 = visual_video_new (); visual_video_copy_attrs (src1, dest); visual_video_copy_attrs (src2, dest); visual_video_allocate_buffer (src1); visual_video_allocate_buffer (src2); visual_morph_set_video (morph, dest); for (i = 0; i < TIMES; i++) { visual_morph_set_rate (morph, rate); visual_morph_run (morph, &audio, src1, src2); rate += 0.1; if (rate > 1.0) rate = 0.0; } printf ("Morph throughput bench %d times depthBPP %d morph: %s\n", TIMES, dest->bpp, (visual_plugin_get_info (visual_morph_get_plugin (morph)))->plugname); return EXIT_SUCCESS; }
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; } }
SADisplay::SADisplay (std::string const& driver_name) : m_impl (new Impl) { m_impl->driver.reset (DisplayDriverFactory::instance().make (driver_name, *this)); if (!m_impl->driver) { throw std::runtime_error ("Failed to load display driver '" + driver_name + "'"); } m_impl->screen = visual_video_new (); }
int main (int argc, char **argv) { VisVideo *dest, *src; int i; visual_init (&argc, &argv); dest = visual_video_new (); visual_video_set_depth (dest, VISUAL_VIDEO_DEPTH_32BIT); visual_video_set_dimension (dest, 640, 400); visual_video_allocate_buffer (dest); src = visual_video_new (); visual_video_clone (src, dest); visual_video_allocate_buffer (src); for (i = 0; i < TIMES; i++) visual_video_blit_overlay (dest, src, 0, 0, TRUE); printf ("Blit overlay %d times\n", TIMES); }
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; }
static void init( int &argc, char **&argv ) { VisVideoDepth depth; visual_init( &argc, &argv ); bin = visual_bin_new (); depth = visual_video_depth_enum_from_value( 24 ); if( !plugin ) plugin = visual_actor_get_next_by_name( 0 ); if( !plugin ) exit( "Actor plugin not found!" ); visual_bin_set_supported_depth( bin, VISUAL_VIDEO_DEPTH_ALL ); if( NULL == (video = visual_video_new()) ) exit( "Cannot create a video surface" ); if( visual_video_set_depth( video, depth ) < 0 ) exit( "Cannot set video depth" ); visual_video_set_dimension( video, 320, 200 ); if( visual_bin_set_video( bin, video ) ) exit( "Cannot set video" ); visual_bin_connect_by_names( bin, (char*)plugin, 0 ); if( visual_bin_get_depth( bin ) == VISUAL_VIDEO_DEPTH_GL ) { visual_video_set_depth( video, VISUAL_VIDEO_DEPTH_GL ); pluginIsGL = true; } SDL::create( 320, 200 ); SDL_WM_SetCaption( plugin, 0 ); /* Called so the flag is set to false, seen we create the initial environment here */ visual_bin_depth_changed( bin ); VisInput *input = visual_bin_get_input( bin ); if( visual_input_set_callback( input, upload_callback, NULL ) < 0 ) exit( "Cannot set input plugin callback" ); visual_bin_switch_set_style( bin, VISUAL_SWITCH_STYLE_MORPH ); visual_bin_switch_set_automatic( bin, true ); visual_bin_switch_set_steps( bin, 100 ); visual_bin_realize( bin ); visual_bin_sync( bin, false ); std::cout << "[PANA] Libvisual version " << visual_get_version() << '\n'; std::cout << "[PANA] bpp: " << video->bpp << std::endl; std::cout << "[PANA] GL: " << (pluginIsGL ? "true\n" : "false\n"); }
int main (int argc, char **argv) { char *d1, *d2; VisVideo *dest, *src; VisVideoDepth depth1, depth2; int i; visual_init (&argc, &argv); if (argc > 2) { d1 = argv[1]; d2 = argv[2]; } else { d1 = strdup("32"); d2 = strdup("16"); } depth1 = visual_video_depth_enum_from_value(atoi(d1)); depth2 = visual_video_depth_enum_from_value(atoi(d2)); dest = visual_video_new (); visual_video_set_depth (dest, depth1); visual_video_set_dimension (dest, 640, 400); visual_video_set_palette (dest, visual_palette_new (256)); visual_video_allocate_buffer (dest); src = visual_video_new (); visual_video_set_depth (src, depth2); visual_video_set_dimension (src, 640, 400); visual_video_set_palette (src, visual_palette_new (256)); visual_video_allocate_buffer (src); for (i = 0; i < TIMES; i++) visual_video_depth_transform (dest, src); printf ("Depth transformed %d times from %s to %s\n", TIMES, d1, d2); }
VisVideo *visual_video_new_with_buffer (int width, int height, VisVideoDepth depth) { VisVideo *video; int ret; video = visual_video_new (); visual_video_set_depth (video, depth); visual_video_set_dimension (video, width, height); ret = visual_video_allocate_buffer (video); if (ret < 0) { visual_object_unref (VISUAL_OBJECT (video)); return NULL; } return video; }
int visual_bin_switch_actor (VisBin *bin, VisActor *actor) { VisVideo *privvid; visual_log_return_val_if_fail (bin != NULL, -1); visual_log_return_val_if_fail (actor != NULL, -1); /* Set the new actor */ bin->actmorph = actor; visual_log (VISUAL_LOG_DEBUG, "entering..."); /* Free the private video */ if (bin->privvid != NULL) { visual_object_unref (VISUAL_OBJECT (bin->privvid)); bin->privvid = NULL; } visual_log (VISUAL_LOG_INFO, _("depth of the main actor: %d"), bin->actor->video->depth); /* Starting the morph, but first check if we don't have anything todo with openGL */ if (bin->morphstyle == VISUAL_SWITCH_STYLE_MORPH && bin->actor->video->depth != VISUAL_VIDEO_DEPTH_GL && bin->actmorph->video->depth != VISUAL_VIDEO_DEPTH_GL && bin->depthfromGL != TRUE) { if (bin->morph != NULL && bin->morph->plugin != NULL) { visual_morph_set_rate (bin->morph, 0); visual_morph_set_video (bin->morph, bin->actvideo); if (bin->morphautomatic == TRUE) visual_morph_set_mode (bin->morph, bin->morphmode); else visual_morph_set_mode (bin->morph, VISUAL_MORPH_MODE_SET); visual_morph_set_time (bin->morph, &bin->morphtime); visual_morph_set_steps (bin->morph, bin->morphsteps); } bin->morphrate = 0; bin->morphstepsdone = 0; visual_log (VISUAL_LOG_DEBUG, "phase 1"); /* Allocate a private video for the main actor, so the morph * can draw to the framebuffer */ privvid = visual_video_new (); visual_log (VISUAL_LOG_DEBUG, "actvideo->depth %d actmorph->video->depth %d", bin->actvideo->depth, bin->actmorph->video->depth); visual_log (VISUAL_LOG_DEBUG, "phase 2"); visual_video_clone (privvid, bin->actvideo); visual_log (VISUAL_LOG_DEBUG, "phase 3 pitch privvid %d actvideo %d", privvid->pitch, bin->actvideo->pitch); visual_video_allocate_buffer (privvid); visual_log (VISUAL_LOG_DEBUG, "phase 4"); /* Initial privvid initialize */ visual_log (VISUAL_LOG_DEBUG, "actmorph->video->depth %d %p", bin->actmorph->video->depth, visual_video_get_pixels (bin->actvideo)); if (visual_video_get_pixels (bin->actvideo) != NULL && visual_video_get_pixels (privvid) != NULL) visual_mem_copy (visual_video_get_pixels (privvid), visual_video_get_pixels (bin->actvideo), visual_video_get_size (privvid)); else if (visual_video_get_pixels (privvid) != NULL) visual_mem_set (visual_video_get_pixels (privvid), 0, visual_video_get_size (privvid)); visual_actor_set_video (bin->actor, privvid); bin->privvid = privvid; } else { visual_log (VISUAL_LOG_DEBUG, "Pointer actvideo->pixels %p", visual_video_get_pixels (bin->actvideo)); if (bin->actor->video->depth != VISUAL_VIDEO_DEPTH_GL && visual_video_get_pixels (bin->actvideo) != NULL) { visual_mem_set (visual_video_get_pixels (bin->actvideo), 0, visual_video_get_size (bin->actvideo)); } } visual_log (VISUAL_LOG_DEBUG, "Leaving, actor->video->depth: %d actmorph->video->depth: %d", bin->actor->video->depth, bin->actmorph->video->depth); bin->morphing = TRUE; 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; }
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; } }
/* 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 (); }
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; } }
/** VisVideo.videoNew() */ JNIEXPORT jint JNICALL Java_org_libvisual_android_VisVideo_videoNew(JNIEnv * env, jobject obj) { LOGI("VisVideo.videoNew()"); return (jint) visual_video_new(); }
/* 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 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; }