static void draw_frame_ov_lv(void * data, gavl_video_frame_t * frame) { lv_priv_t * priv; priv = (lv_priv_t*)data; visual_video_set_buffer(priv->video, frame->planes[0]); visual_video_set_pitch(priv->video, frame->strides[0]); visual_actor_run(priv->actor, priv->audio); priv->have_audio = 0; }
static void draw_frame_gl_lv(void * data, gavl_video_frame_t * frame) { lv_priv_t * priv; priv = (lv_priv_t*)data; bg_x11_window_set_gl(priv->win); visual_actor_run(priv->actor, priv->audio); bg_x11_window_unset_gl(priv->win); priv->have_audio = 0; }
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; }
/* 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; }
static GstFlowReturn gst_visual_chain (GstPad * pad, GstBuffer * buffer) { GstBuffer *outbuf = NULL; guint i; GstVisual *visual = GST_VISUAL (gst_pad_get_parent (pad)); GstFlowReturn ret = GST_FLOW_OK; guint avail; GST_DEBUG_OBJECT (visual, "chain function called"); /* If we don't have an output format yet, preallocate a buffer to try and * set one */ if (GST_PAD_CAPS (visual->srcpad) == NULL) { ret = get_buffer (visual, &outbuf); if (ret != GST_FLOW_OK) { gst_buffer_unref (buffer); goto beach; } } /* resync on DISCONT */ if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) { gst_adapter_clear (visual->adapter); } GST_DEBUG_OBJECT (visual, "Input buffer has %d samples, time=%" G_GUINT64_FORMAT, GST_BUFFER_SIZE (buffer) / visual->bps, GST_BUFFER_TIMESTAMP (buffer)); gst_adapter_push (visual->adapter, buffer); while (TRUE) { gboolean need_skip; const guint16 *data; guint64 dist, timestamp; GST_DEBUG_OBJECT (visual, "processing buffer"); avail = gst_adapter_available (visual->adapter); GST_DEBUG_OBJECT (visual, "avail now %u", avail); /* we need at least 512 samples */ if (avail < 512 * visual->bps) break; /* we need at least enough samples to make one frame */ if (avail < visual->spf * visual->bps) break; /* get timestamp of the current adapter byte */ timestamp = gst_adapter_prev_timestamp (visual->adapter, &dist); if (GST_CLOCK_TIME_IS_VALID (timestamp)) { /* convert bytes to time */ dist /= visual->bps; timestamp += gst_util_uint64_scale_int (dist, GST_SECOND, visual->rate); } if (timestamp != -1) { gint64 qostime; /* QoS is done on running time */ qostime = gst_segment_to_running_time (&visual->segment, GST_FORMAT_TIME, timestamp); GST_OBJECT_LOCK (visual); /* check for QoS, don't compute buffers that are known to be late */ need_skip = visual->earliest_time != -1 && qostime <= visual->earliest_time; GST_OBJECT_UNLOCK (visual); if (need_skip) { GST_WARNING_OBJECT (visual, "QoS: skip ts: %" GST_TIME_FORMAT ", earliest: %" GST_TIME_FORMAT, GST_TIME_ARGS (qostime), GST_TIME_ARGS (visual->earliest_time)); goto skip; } } /* Read 512 samples per channel */ data = (const guint16 *) gst_adapter_peek (visual->adapter, 512 * visual->bps); #if defined(VISUAL_API_VERSION) && VISUAL_API_VERSION >= 4000 && VISUAL_API_VERSION < 5000 { VisBuffer *lbuf, *rbuf; guint16 ldata[512], rdata[512]; VisAudioSampleRateType rate; lbuf = visual_buffer_new_with_buffer (ldata, sizeof (ldata), NULL); rbuf = visual_buffer_new_with_buffer (rdata, sizeof (rdata), NULL); if (visual->channels == 2) { for (i = 0; i < 512; i++) { ldata[i] = *data++; rdata[i] = *data++; } } else { for (i = 0; i < 512; i++) { ldata[i] = *data; rdata[i] = *data++; } } switch (visual->rate) { case 8000: rate = VISUAL_AUDIO_SAMPLE_RATE_8000; break; case 11250: rate = VISUAL_AUDIO_SAMPLE_RATE_11250; break; case 22500: rate = VISUAL_AUDIO_SAMPLE_RATE_22500; break; case 32000: rate = VISUAL_AUDIO_SAMPLE_RATE_32000; break; case 44100: rate = VISUAL_AUDIO_SAMPLE_RATE_44100; break; case 48000: rate = VISUAL_AUDIO_SAMPLE_RATE_48000; break; case 96000: rate = VISUAL_AUDIO_SAMPLE_RATE_96000; break; default: visual_object_unref (VISUAL_OBJECT (lbuf)); visual_object_unref (VISUAL_OBJECT (rbuf)); GST_ERROR_OBJECT (visual, "unsupported rate %d", visual->rate); ret = GST_FLOW_ERROR; goto beach; break; } visual_audio_samplepool_input_channel (visual->audio->samplepool, lbuf, rate, VISUAL_AUDIO_SAMPLE_FORMAT_S16, (char *) VISUAL_AUDIO_CHANNEL_LEFT); visual_audio_samplepool_input_channel (visual->audio->samplepool, rbuf, rate, VISUAL_AUDIO_SAMPLE_FORMAT_S16, (char *) VISUAL_AUDIO_CHANNEL_RIGHT); visual_object_unref (VISUAL_OBJECT (lbuf)); visual_object_unref (VISUAL_OBJECT (rbuf)); } #else if (visual->channels == 2) { for (i = 0; i < 512; i++) { visual->audio->plugpcm[0][i] = *data++; visual->audio->plugpcm[1][i] = *data++; } } else { for (i = 0; i < 512; i++) { visual->audio->plugpcm[0][i] = *data; visual->audio->plugpcm[1][i] = *data++; } } #endif /* alloc a buffer if we don't have one yet, this happens * when we pushed a buffer in this while loop before */ if (outbuf == NULL) { ret = get_buffer (visual, &outbuf); if (ret != GST_FLOW_OK) { goto beach; } } visual_video_set_buffer (visual->video, GST_BUFFER_DATA (outbuf)); visual_audio_analyze (visual->audio); visual_actor_run (visual->actor, visual->audio); visual_video_set_buffer (visual->video, NULL); GST_DEBUG_OBJECT (visual, "rendered one frame"); GST_BUFFER_TIMESTAMP (outbuf) = timestamp; GST_BUFFER_DURATION (outbuf) = visual->duration; ret = gst_pad_push (visual->srcpad, outbuf); outbuf = NULL; skip: GST_DEBUG_OBJECT (visual, "finished frame, flushing %u samples from input", visual->spf); /* Flush out the number of samples per frame */ gst_adapter_flush (visual->adapter, visual->spf * visual->bps); /* quit the loop if something was wrong */ if (ret != GST_FLOW_OK) break; } beach: if (outbuf != NULL) gst_buffer_unref (outbuf); gst_object_unref (visual); return ret; }
static gboolean gst_visual_render (GstAudioVisualizer * bscope, GstBuffer * audio, GstVideoFrame * video) { GstVisual *visual = GST_VISUAL (bscope); GstMapInfo amap; const guint16 *adata; gint i, channels; gboolean res = TRUE; VisBuffer *lbuf, *rbuf; guint16 ldata[VISUAL_SAMPLES], rdata[VISUAL_SAMPLES]; VisAudioSampleRateType vrate; visual_video_set_buffer (visual->video, GST_VIDEO_FRAME_PLANE_DATA (video, 0)); visual_video_set_pitch (visual->video, GST_VIDEO_FRAME_PLANE_STRIDE (video, 0)); channels = GST_AUDIO_INFO_CHANNELS (&bscope->ainfo); gst_buffer_map (audio, &amap, GST_MAP_READ); adata = (const guint16 *) amap.data; lbuf = visual_buffer_new_with_buffer (ldata, sizeof (ldata), NULL); rbuf = visual_buffer_new_with_buffer (rdata, sizeof (rdata), NULL); if (channels == 2) { for (i = 0; i < VISUAL_SAMPLES; i++) { ldata[i] = *adata++; rdata[i] = *adata++; } } else { for (i = 0; i < VISUAL_SAMPLES; i++) { ldata[i] = *adata; rdata[i] = *adata++; } } /* TODO(ensonic): move to setup */ switch (bscope->ainfo.rate) { case 8000: vrate = VISUAL_AUDIO_SAMPLE_RATE_8000; break; case 11250: vrate = VISUAL_AUDIO_SAMPLE_RATE_11250; break; case 22500: vrate = VISUAL_AUDIO_SAMPLE_RATE_22500; break; case 32000: vrate = VISUAL_AUDIO_SAMPLE_RATE_32000; break; case 44100: vrate = VISUAL_AUDIO_SAMPLE_RATE_44100; break; case 48000: vrate = VISUAL_AUDIO_SAMPLE_RATE_48000; break; case 96000: vrate = VISUAL_AUDIO_SAMPLE_RATE_96000; break; default: visual_object_unref (VISUAL_OBJECT (lbuf)); visual_object_unref (VISUAL_OBJECT (rbuf)); GST_ERROR_OBJECT (visual, "unsupported rate %d", bscope->ainfo.rate); res = FALSE; goto done; } visual_audio_samplepool_input_channel (visual->audio->samplepool, lbuf, vrate, VISUAL_AUDIO_SAMPLE_FORMAT_S16, (char *) VISUAL_AUDIO_CHANNEL_LEFT); visual_audio_samplepool_input_channel (visual->audio->samplepool, rbuf, vrate, VISUAL_AUDIO_SAMPLE_FORMAT_S16, (char *) VISUAL_AUDIO_CHANNEL_RIGHT); visual_object_unref (VISUAL_OBJECT (lbuf)); visual_object_unref (VISUAL_OBJECT (rbuf)); visual_audio_analyze (visual->audio); visual_actor_run (visual->actor, visual->audio); visual_video_set_buffer (visual->video, NULL); GST_DEBUG_OBJECT (visual, "rendered one frame"); done: gst_buffer_unmap (audio, &amap); return res; }
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 void render_frame (GstVisualGL * visual) { const guint16 *data; VisBuffer *lbuf, *rbuf; guint16 ldata[VISUAL_SAMPLES], rdata[VISUAL_SAMPLES]; guint i; gcahr *name; /* Read VISUAL_SAMPLES samples per channel */ data = (const guint16 *) gst_adapter_peek (visual->adapter, VISUAL_SAMPLES * visual->bps); lbuf = visual_buffer_new_with_buffer (ldata, sizeof (ldata), NULL); rbuf = visual_buffer_new_with_buffer (rdata, sizeof (rdata), NULL); if (visual->channels == 2) { for (i = 0; i < VISUAL_SAMPLES; i++) { ldata[i] = *data++; rdata[i] = *data++; } } else { for (i = 0; i < VISUAL_SAMPLES; i++) { ldata[i] = *data; rdata[i] = *data++; } } visual_audio_samplepool_input_channel (visual->audio->samplepool, lbuf, visual->libvisual_rate, VISUAL_AUDIO_SAMPLE_FORMAT_S16, VISUAL_AUDIO_CHANNEL_LEFT); visual_audio_samplepool_input_channel (visual->audio->samplepool, rbuf, visual->libvisual_rate, VISUAL_AUDIO_SAMPLE_FORMAT_S16, VISUAL_AUDIO_CHANNEL_RIGHT); visual_object_unref (VISUAL_OBJECT (lbuf)); visual_object_unref (VISUAL_OBJECT (rbuf)); visual_audio_analyze (visual->audio); /* apply the matrices that the actor set up */ glPushAttrib (GL_ALL_ATTRIB_BITS); glMatrixMode (GL_PROJECTION); glPushMatrix (); glLoadMatrixd (visual->actor_projection_matrix); glMatrixMode (GL_MODELVIEW); glPushMatrix (); glLoadMatrixd (visual->actor_modelview_matrix); /* This line try to hacks compatiblity with libprojectM * If libprojectM version <= 2.0.0 then we have to unbind our current * fbo to see something. But it's incorrect and we cannot use fbo chainning (append other glfilters * after libvisual_gl_projectM will not work) * To have full compatibility, libprojectM needs to take care of our fbo. * Indeed libprojectM has to unbind it before the first rendering pass * and then rebind it before the final pass. It's done from 2.0.1 */ name = gst_element_get_name (GST_ELEMENT (visual)); if (g_ascii_strncasecmp (name, "visualglprojectm", 16) == 0 && !HAVE_PROJECTM_TAKING_CARE_OF_EXTERNAL_FBO) glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0); g_free (name); actor_negotiate (visual->display, visual); if (visual->is_enabled_gl_depth_test) { glEnable (GL_DEPTH_TEST); glDepthFunc (visual->gl_depth_func); } if (visual->is_enabled_gl_blend) { glEnable (GL_BLEND); glBlendFunc (visual->gl_blend_src_alpha, GL_ZERO); } visual_actor_run (visual->actor, visual->audio); check_gl_matrix (); glMatrixMode (GL_PROJECTION); glPopMatrix (); glMatrixMode (GL_MODELVIEW); glPopMatrix (); glPopAttrib (); glDisable (GL_DEPTH_TEST); glDisable (GL_BLEND); /*glDisable (GL_LIGHT0); glDisable (GL_LIGHTING); glDisable (GL_POLYGON_OFFSET_FILL); glDisable (GL_COLOR_MATERIAL); glDisable (GL_CULL_FACE); */ GST_DEBUG_OBJECT (visual, "rendered one frame"); }
/* 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 (); }