THIS ITEM WAS REASSIGNED TO TASK #7058

Please, do not post any new comments to this item.

I think bastiaan fixed this lately, right ?

Please just document this as usual with comments in the code, I'm very busy with memory corruption at the moment and have to postpone   this "Gui" tasks, I'd just like not to discard the whole discussion so far.

Have a look at my longer mailing list posting.

When Gui::set_invalidated_bounds() is called it means:

"Hey GUI, just to let you know, I will call display() soon and these are the coordinates that have changed in the movie for sure. Do whatever you want with it".

GTK-AGG then says:

"Oh, good to know, I'll tell the renderer that he can forget about the area outside these bounds and I'll copy the offscreen buffer only in that region. Oh, I just noticed that on my left side I have been uncovered and I have to redraw, so I'll ask the renderer to redraw that part too."

Clear now? ;)

I understand that the concept may be confusing...

You can keep a gnash::rect that holds information about re-exposed regions since the last display() call. It's easy to extend this rect using the class functions.

When you get the set_invalidated_bounds() call, extend the bounds to that rect before passing it to the renderer.

When receiving the expose event, just trigger display().

Don't know if it makes much sense but you could throttle the re-displaying using a one-shot timer (to skip quickly consecutive events). But I'm not that familiar with the GTK architecture to tell if this is complete nonsense.

Just to understand Udo's proposal right:
At least for GTK I don't know a way to determine the visible region of the window. The expose event just tells what previously hidden region has to be redrawn. So, when calling display() the "exposed_region_rect" can be either the whole window region, the region for the exposed part of the window (which we get from the expose event) or NULL for an invisible window. Right?

Ok, I understand your proposal.
But unless we change more parts of the code this would go an odd way:

- the exposed_region_rectangle is defined
- display() is called passing the exposed_region_rectangle
- the invalidated bounds are searched
- the intersection of these bounds is calculated
- Gui::set_invalidated_bounds() is called (so the info is passed back to the GUI!)
- render_handler::set_invalidated_bounds() is called
[BTW, don't forget that advance_movie() needs to know exposed_region_rectangle too]

as opposed to the current implementation:

- display() is called (maype indirectly via advance_movie), just like now
- the invalidated bounds are searched
- Gui::set_invalidated_bounds() is called, which intersects it with the current exposed rect (only code change is here!)
- render_handler::set_invalidated_bounds() is called with the new coordinates

IMHO the GUI (not gui.cpp) just needs to call a new advance_movie()-like method that avoids rendering.

The best would be to split Gui::advance_movie() and trigger rendering with a separate function.

This has the advantage that the individual GUI can re-render without advancing the frame and vice-versa.

Something like:

bool
Gui::advance_movie(Gui* gui)
{
assert(gui);
gnash::movie_interface* m = gnash::get_current_root();
// Advance movie by one frame
m->advance(1.0);
}

Gui::render(Gui* gui)
{
assert(gui);
gnash::movie_interface* m = gnash::get_current_root();
gui->display(m);

if ( ! gui->loops() )
{
size_t curframe = m->get_current_frame();
gnash::sprite_instance* si = m->get_root_movie();
if (curframe + 1 == si->get_frame_count())
{
    exit(0); // TODO: quit in a more gentile fashion.
}
}

return true;
}


BTW, the gui.cpp, GUI and GUI glue naming is very confusing...

IMHO, audio should continue playing, and should be kept in sync with the visuals. But I guess there is still a lot of CPU to be saved: No actual (vector) rendering is needed, no X server communication is needed.

THIS ITEM WAS REASSIGNED TO TASK #7058
Gnash should notice when its window is not visible on the screen, and stop burning CPU to update it.  (It burns 100% of one of my CPUs when I have the X server's hardware acceleration off, run the standalone player with the JibJab.com "This Land is Your Land" .swf file, and then iconify the window.)

The same optimization should be made if the window is 100% hidden behind another window.