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 int render_now(LVAVSPipelineContainer *container, VisVideo *video, VisAudio *audio, int s) { LVAVSPipeline *pipeline = LVAVS_PIPELINE_ELEMENT(container)->pipeline; int i; int count = visual_list_count(container->members); for(i = 0; i < count; i++) { LVAVSPipelineElement *element = visual_list_get(container->members, i); VisVideo *tmpvid; if(s) { pipeline->framebuffer = visual_video_get_pixels(pipeline->dummy_vid); pipeline->fbout = visual_video_get_pixels(video); } else { pipeline->fbout = visual_video_get_pixels(pipeline->dummy_vid); pipeline->framebuffer = visual_video_get_pixels(video); } switch (element->type) { case LVAVS_PIPELINE_ELEMENT_TYPE_ACTOR: visual_actor_set_video (element->data.actor, video); visual_actor_run (element->data.actor, audio); break; case LVAVS_PIPELINE_ELEMENT_TYPE_TRANSFORM: visual_transform_set_video (element->data.transform, video); visual_transform_run (element->data.transform, audio); break; case LVAVS_PIPELINE_ELEMENT_TYPE_CONTAINER: pipeline_container_run (LVAVS_PIPELINE_CONTAINER (element), video, audio); break; default: break; } if(pipeline->swap&1) { s^=1; pipeline->swap = 0; } } return s; }
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 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; }
/* 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 (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; }
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; }
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; } }
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; }
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; } }
/* 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 (); }