GitLab

This avoids both function call overhead and extra checks for values that
are outside MININT/MAXINT range, for the uses inside GeglBuffer we only
care about coordinates that are representable as integers - thus these
inline-able shortcut versions are good enough for us.

The speedup seems to consistently make all samplers about 10% faster
according to the tests in perf/

This makes loading code not crash when loading buffers that have been saved
with a non NULL/sRGB space.

As a reminder that we are losing space information we warn in the instances
when it happens.

By recursing through the states in the render path we execute all the non-core
parts serially at a slightly higher efficiency than returning to the main loop.

This is a command to be used when a specific property of an active
node is selected for editing, for now only doing linear interpolation
even though the GeglPath used underneath is a full bezier curve and
more interpolator.

 keyframe list
   prints the set keyframes
 keyframe set [prop] [value] [time]
   sets the currently set property value as a keyframe at current time
   overriding possible existing value
 keyframe toggle
   sets the currently set propery value as keyframe value at current time
   if doing so would be a no-op unset the existing value instead.
 keyframe clear
   removes animation curve of current property

The keybindings for "keyframe toggle" is control-k or just ` which is
easily accesible on english layouts.

When enabled GEGL is caching all rendered frames and associated pcm data for
now uncompressed, you should have enough disk-space - and without deleting
stale data, and for many uses the disk space used is excessive, it will be
suited for realtime playback and editing of short segments, adding more file
formats will make it usable will less scratch disk-space, as a solution with
SSD it seems to make for a very good real-time full resolution preview backing
cache.

This serializes the currently set animated property values - instead of the
full keyframed animation. This will enable rendered frame caching in the UI.

This controls if we loop on current clip or go to next clip at end
of duration during when playing.

Not neccesary to fix the crash in issue #151, but adds these now fully expected
in babl encodings to what GEGL also expects.

This is a way to avoid the warnings seen in issue #142, using the lua
interface code now is matching the pure C UI in not showing leaks during
basic image opening/closing browsing.

This special cases files without a video track to compute relevant pre-decoded
audio segment based on frame and frame rate, rather than presentation time
stamps as when decoding video.

in GeglTileBackendSwap, use the tile- and scratch-allocators for
temporary compression buffers, to improve performance.

In GeglTile, use gegl-tile-alloc for tile data, instead of the
normal allocator.

Note that the tile allocator guarantees that allocated buffers are
preceeded by sufficient room for the n_clones array, which
simplifies the allocation of a shared n_clones+data buffer.

Add gegl-tile-alloc -- a dedicated allocator for tile data.  The
allocator amortizes the cost of memory allocation, which is
especially high on Windows, over multiple tiles, by allocating
tiles in bulk, in groups called blocks (currently, each block is
roughly 1% of the tile-cache size.)

The allocator is currently limited to tiles whose size is a power
of 2, possibly multiplied by 3 or 5 (to support tiles whose
dimensions are powers of 2, with up to 5 components).  The rest of
the tiles are allocated using the normal allocator.

Move the call to malloc_trim() from GeglBuffer's destructor to
gegl-tile-alloc.  We call it whenever tile data equivalent to ~10%
of the tile-cache size is freed.

Add a tile-alloc-total stat, which reports the total amount of
memory currently used by the tile allocator.

In gegl-scratch, avoid relying on exact struct layout to guarantee
data alignment, and rather use explicit pointer arithmetic instead.

Rename the GEGL_ALIGN constant (specifying allocated data
alignment) to GEGL_ALIGNMENT, and add a GEGL_ALIGN() macro, which
takes a size/address value and aligns it to GEGL_ALIGN.

Use GIT_STRATEGY: none to prevent cloning gegl in babl-git and opencl dependency jobs.
Restrict explicit git clones.
Fetch babl tags explicitly.
Signed-off-by: Jan Vesely <jano.vesely@gmail.com>

Signed-off-by: Jan Vesely <jano.vesely@gmail.com>

Signed-off-by: Jan Vesely <jano.vesely@gmail.com>

Fixes clones.xml on nVidia OpenCL and Intel beignet.
Signed-off-by: Jan Vesely <jano.vesely@gmail.com>

In gegl_tile_handler_cache_copy(), when the source cache doesn't
have the requested tile, remove the tile from the destination cache
*before* letting the backend copy the tile, since it might copy it
into the destination cache as well, as happens with
GeglTileBackendBuffer.  Previously, this would happen *after* the
backend copied the tile, erroneously invalidating the copied tile
in this case.  See issue #157.

Also, don't invalidate the destination tile in this case, since
gegl_buffer_copy() invalidates the entire affected region in bulk.

In the various GeglOperation subclasses that use a per-thread
indirect input-buffer, backed by the actual input buffer, during
multithreaded processing, use an indirect buffer for the main
thread as well, instead of using the input buffer directly
(unless the main thread processes the entire output).

This avoids a deadlock when multiple threads gegl_buffer_copy()
from their input buffer to the output buffer concurrently: if a
worker thread acquires both the (indirect) input-buffer and output-
buffer locks, while the main thread acquires the (direct) input-
buffer lock and waits on the output-buffer lock, as soon as the
GeglTileBackendBuffer of the worker-thread's input buffer forwards
a command to the underlying input buffer, it will deadlock while
waiting for the input-buffer's lock (which is held by the main
thread).  See issue #157.

Furthermore, this should reduce contention over the underlying
input buffer between the main thread and the worker threads.

In gegl_buffer_copy(), when using COW, sort the locks by the tile-
storage pointers, instead of the buffer pointers, to avoid the
possibility of a deadlock when different buffers use the same
underlying storage in concurrent calls to the function.