I just ran my script (email to follow) to migrate all of the EFL
automatically. This commit is *only* the automatic conversion, so it can
be easily reverted and re-run.
This patch fixes an Coverity issue that if 'dst' gets set to NULL (as can
happen above) then this eo_do call may segfault as it is directly
accessing 'dst->buffer'.
@fix
CID1347415
Signed-off-by: Chris Michael <cpmichael@osg.samsung.com>
out was simply not initialized if the source and destination
were the same. The COW flag is required here to separate input
and output properly. Also, the source & destination pointers
were badly calculated and could overflow.
Instead of using memcpy this filter was supposed to use the
blend functions. This patch also fixes that.
In order to make this filter actually useful (think text reflection
on a flat surface), more information needs to be passed to the Lua
script, such as the text ascent, descent, etc...
This is a minor change, makes 'output' the default target for
the transform filter. This is consistent with all the other
filters. This is not exactly a bug fix but it doesn't break
compatibility with the earlier explicit form and improves the API
for 1.17.
SW async render mode was broken because it was party sync, partly
async (bad hack in a recent commit). This patch fixes that by
using a proper callback for render_post (main loop).
Since the engines and ector now abstract all pixel access functions,
the only difference between GL and SW is the async rendering.
This implements a generic way of scaling buffers, using fake
RGBA_Image wrapping ector buffer maps. The underlying algo is
still the good old linear sw scaler.
Now the filters *should* be back to their previous level of
usability. Performance will probably be even worse than it was
before, for GL, as more glReadPixels may be involved. Optimization
now consists in actually implementing the filters with GL shaders.
Evas filters is now more and more unaware of evas images (RGBA_Image)
and the engine + ector take care of everything.
Still left to do:
- map / unmap an FBO buffer into RO or RW memory
This fixes crashes, adds safety, and notes a couple of things that
are not yet implemented:
- Make an Evas_GL_Image from an RGBA_Image so we can draw it on the
canvas. This means Evas.Ector.GL.RGBA_Image.Buffer
- Readable Evas_GL_Image objects with gl_read_pixels
--> Implement proper map() & unmap() for GL buffers
Since Ector Buffer implicitly converts colorspaces, we
can allow more commands to work even if they are suboptimal.
Now all filters should support any combinaison of input, map/mask
and output colorspaces.
This is a major refactoring of the evas filters submodule.
Use Ector.Buffer and the map/unmap methods instead of directly
accessing image buffers with RGBA_Image. RGBA_Image is still
used under the hood, for two reasons:
- Required for the final output (blend onto Evas itself)
- Required for the scaling routines
FIXME:
- Breaks proxy support (ie. all kind of texturing).
- This breaks filters support for the GL engine.
This operation was faked by running a mul and a blend ops. Now
they are combined into one. A GL shader should also be able
to do this in a single pass.
In a rare situation the filter would access an invalid buffer.
Solution: Stop messing with buffer references by properly
referencing and releasing them when not needed, rather
than stealing references and hoping for the best. (There were
flags tracking stolen references, but that was still madness)
After clip_image_get, the old mask may be replaced by a new one,
and unref'ed, but it is later on set back as the context mask image.
Maybe it's possible that there was 0 reference and the image
got freed in between.
No idea how to test this.
@fix
In order to do that, avoid creating multiple Buffer instances
when pointing to the same proxy source. This fixes buffer.width
and buffer.height in Lua.
This fixes filters on Ubuntu 32 bits.
This was one hell of a weird bug to track down. Everything worked
like a charm on my 64 bit machines, but filters would simply fail
for no good reason: a safety check sees a NULL pointer when clearly
it was properly allocated.
Just after entering a function, the content of an RGBA_Image would
change, even though there was no memory write there. This made the
image data pointer NULL, and filters would fail miserably.
So I printed out the contents of the RGBA_Image, they changed. But
the memory itself had not changed. The size of the struct itself
had changed when jumping from one file to another! But its definition
had not! Non-sense!
Unless of course a system header file was included before config.h
and ino_t or off_t would switch between 32 and 64 bits...
@fix
For compatibility with previous behaviour and with what the doc
says, make sure default alpha is 255 and not 0.
This way color(0) is black and not transparent
The previous API supported stuff like "mask{'image1'}" but image1
is now not a valid buffer name, as it's only the proxy source name.
This patch fixes the buffer lookup.
This flag should be set iif the string passed is to be executed
rather than assigned. This is used to pass complex arguments
as data, like tables (eg. color class).
Makes sure that buffers don't override already existing
globals vars such as 'mask' (a function name). Yeah, it happened
to me.
CC support is a little bit hackish. Need to find a better way.
Tom Hacohen
Jean-Philippe Andre
Chris Michael
Stefan Schmidt