this documentation is generated from the information the plug-ins register themselves
|
avi
|
| loads a frame from an avi file using avilib stubs for demuxing and thus allowing random access, and ffmpeg's libavcodec for decoding |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
frame:
|
the request frame number |
|
frames:
|
number of frames in file, a processing run is needed for the value to updated after setting resource |
|
height:
|
height of frames |
|
resource:
|
file to open for reading |
|
speed:
|
speed of playback, used as a shortcut in bauxite to attain slow/fast motion |
|
width:
|
width of frames |
| |
|
blank
|
| creates a new blank image of specified dimensions |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
height:
|
height of new buffer |
|
pixfmt:
|
the pixel format to create, gF, rgbF, rgbaF, rgb8, rgba8, rgb16,.. |
|
width:
|
width of new buffer |
| |
|
clone
|
| clone is a gggl op that needs oxide to fully function when used with oxide it gains the capability to alias another element in the composition tree be aware that best practice is to put the element within a sequence and use the clone outside the sequence, as opposed to use the clone inside the sequence. Doing otherwise might result in property problems. |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
| |
|
ff
|
| ffmpeg based loader using libavcodec for decoding and libavformat fordemuxing, current has issues with random access, but allows for many interesting media formats, as well as specifying png image sequences, refer to ffmpeg documentation for closer details of specification format for image sequences |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
frame:
|
frame number to retrieve |
|
frames:
|
total number of frames in resource |
|
height:
|
height of frames |
|
resource:
|
file to input, might also be a v4l device, image sequence etc.. refer to ffmpeg documentation for more information |
|
width:
|
width of frames |
| |
|
memsrc
|
| Uses a direct memory pointer to a GgglImage structure |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
gggl_image:
|
pointer to memory address containing a GgglImage |
| |
|
mlt
|
| move import filter based on the mlt framework http://mlt.sourceforge.net/ provides many input formats with random access |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
fps:
|
framerate |
|
frame:
|
current frame provided |
|
frames:
|
total number of frames |
|
height:
|
height of frames |
|
resource:
|
file to load |
|
width:
|
width of frames |
| |
|
new
|
| creates a new blank image of specified dimensions |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
height:
|
height of new buffer |
|
pixfmt:
|
the pixel format to create, gF, rgbF, rgbaF, rgb8, rgba8, rgb16,.. |
|
width:
|
width of new buffer |
| |
|
noise
|
| perlin noise |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
render |
| | | |
|
alpha:
|
kind of contrast |
|
height:
|
height of buffer |
|
n:
|
number of octaves |
|
scale:
|
scale of noise |
|
width:
|
width of buffer |
|
xoff:
|
x offset into noise space |
|
yoff:
|
y offset into noise space |
|
zoff:
|
z offset into noise space |
| |
|
png
|
| png file loader, able to load rgb and grayscale images, with and without alpha in both 8 and 16 bit/channel |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
resource:
|
file to load |
| |
|
svg
|
| svg loader using libsvg-cairo, the loaded image is scale to fit within specified width/height, if no width/height is specified the default of the file will be used |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
height:
|
height of provided image buffer, -1 for auto |
|
resource:
|
svg file to load |
|
width:
|
width of provided image buffer, -1 for auto |
| |
|
text
|
| text rendering using cairo,. setting of color is not implemented yet,. a workaround is to use the color balance filter on the output of text |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
font:
|
which font to use |
|
size:
|
letter height in pixels |
|
string:
|
the string to print, embedded newlines are allowed |
| |
|
v4l
|
| video4linux input source, can be used for webcams, tv pci cards, and probably vloopback (not tested), at the moment the pixel format is assumed to be the one returned by the authors webcam (using the pwc driver) |
input_pads: |
0 |
| output_pads: |
1 |
| category: |
source |
| | | |
|
height:
|
height of capture |
|
resource:
|
capture device |
|
width:
|
width of capture |
| |
|
display
|
| uses gtkcairo for displaying output, NB: setting the enviroment variable GTKCAIRO_BACKEND=gl will make gtkcairo use glitz for rendering, thus attaining hardware scaling |
input_pads: |
1 |
| output_pads: |
0 |
| category: |
sink |
| | | |
|
title:
|
title used for window / buffer |
| |
|
ff_save
|
| video encoder based on ffmpeg, uses libavformat and libavcodec for encoding output files, may also do image sequences and other things supported through ffmpeg's standard interface, to write to a png sequence specify and output resource like %04d.png |
input_pads: |
1 |
| output_pads: |
0 |
| category: |
sink |
| | | |
|
bitrate:
|
bitrate,. 700=kbs 7000000=70000kbit/sek |
|
fps:
|
framerate |
|
resource:
|
file to write to (or ffmpeg based pattern for png sequence) |
| |
|
memdst
|
| write directly to a GgglImage residing in memory |
input_pads: |
1 |
| output_pads: |
0 |
| category: |
sink |
| | | |
|
gggl_image:
|
pointer to GgglImage structure |
| |
|
null
|
| bit sink can be used to "terminate" an image processing chain |
input_pads: |
1 |
| output_pads: |
0 |
| category: |
sink |
| | | |
| |
|
png_save
|
| png file saveer, able to save rgb and grayscale images, with and without alpha in both 8 and 16 bit/channel |
input_pads: |
1 |
| output_pads: |
0 |
| category: |
sink |
| | | |
|
compression:
|
png compression level (0 fastest-> 9 best) |
|
frame:
|
frame number to be substituted into filename when saving, only used if resource contains #, the file is expanded to have five digits, padded with 0's |
|
hdpi:
|
horizontal dpi (defaults to 72) |
|
resource:
|
path to file to be written |
|
vdpi:
|
vertical dpi (defaults to 72) |
| |
|
add_constant
|
| add each component with the value from auxiliary input |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
constant |
| | | |
|
value:
|
value to use in operation |
| |
|
autostretch
|
| automatically stretch lumniosity values to use full range |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
| |
|
bcontrast
|
| brightness and contrast adjustment |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
|
brightness:
|
relative adjustment of contrast 0.0 = no adjustment 1.0 = burn out to white, -1.0 black,. |
|
contrast:
|
contrast multiplier, 1.0 = no change 2.0 = double contrast 0.5 = halve contrast |
| |
|
boxblur
|
| boxblur filter |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
blur |
| | | |
|
horizontal:
|
horizontal blur radius |
|
vertical:
|
vertical blur radius |
| |
|
bubbles
|
| interactive balloons,. needs an obstacle mask as primary input, the obstacle mask is considered in a 1bit fashion, but could probably be considered 8bit as is,. interpolation might be done with a post the fact antialiasing. |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
interactive |
| | | |
|
bubbles:
|
number of bubbles |
|
radius:
|
bubble radius |
|
speed:
|
number of time iterations per frame |
| |
|
cb
|
| extract cb component from color image |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
|
| | | |
| |
|
clamp
|
| restrict allowed range, values above or below the specified min, and max values are set to min/max. |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
|
max:
|
maximum allowed value |
|
min:
|
minimum allowed value |
| |
|
color_detect
|
| color detector |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
tutorial |
| | | |
|
blue:
|
target blue |
|
green:
|
target green |
|
red:
|
target red |
| |
|
colorbalance
|
| color correction in yuv space, should probably be ported to LAB, allows setting of whitepoint, graypoint, blackpoint, tuning saturation, opacity, brightness and contrast in a single op |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
|
brightness:
|
relative brightness adjustment -1..1 |
|
bu:
|
black point offset in u |
|
bv:
|
black point offset in v |
|
contrast:
|
contrast multiplier 1.0 = no change |
|
gu:
|
gray point offset in u |
|
gv:
|
gray point offset in v |
|
opacity:
|
opacity change |
|
saturation:
|
saturation multiplier 1.0 = no change |
|
wu:
|
white point offset in u |
|
wv:
|
white point offset in v |
| |
|
component
|
| extracts a single component from a buffer |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
|
band:
|
the band to extract |
| |
|
cr
|
| extract cr component from image |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
|
| | | |
| |
|
curve
|
| adjusts the lumniosity of the image according to curve. implemented using linear interpolation between the specified mappings. |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
|
stops_used:
|
how many of the in/out value pairs are used |
|
val-00:
|
|
|
val-01:
|
|
|
val-02:
|
|
|
val-03:
|
|
|
val-04:
|
|
|
val-05:
|
|
|
val-06:
|
|
|
val-07:
|
|
|
val-08:
|
|
|
val-09:
|
|
|
val-10:
|
|
|
val-11:
|
|
|
val-12:
|
|
|
val-13:
|
|
|
val-14:
|
|
|
val-15:
|
|
|
val-16:
|
|
|
val-17:
|
|
|
val-18:
|
|
|
val-19:
|
|
|
val-20:
|
|
|
val-21:
|
|
|
val-22:
|
|
|
val-23:
|
|
|
val-24:
|
|
|
val-25:
|
|
|
val-26:
|
|
|
val-27:
|
|
|
val-28:
|
|
|
val-29:
|
|
|
val-30:
|
|
|
val-31:
|
|
|
val-32:
|
|
|
val-33:
|
|
|
val-34:
|
|
|
val-35:
|
|
|
val-36:
|
|
|
val-37:
|
|
|
val-38:
|
|
|
val-39:
|
|
|
val-40:
|
|
|
val-41:
|
|
|
val-42:
|
|
|
val-43:
|
|
|
val-44:
|
|
|
val-45:
|
|
|
val-46:
|
|
|
val-47:
|
|
|
val-48:
|
|
|
val-49:
|
|
|
val-50:
|
|
|
val-51:
|
|
|
val-52:
|
|
|
val-53:
|
|
|
val-54:
|
|
|
val-55:
|
|
|
val-56:
|
|
|
val-57:
|
|
|
val-58:
|
|
|
val-59:
|
|
|
val-60:
|
|
|
val-61:
|
|
|
val-62:
|
|
|
val-63:
|
|
| |
|
difference_constant
|
| difference each component with the value from auxiliary input |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
constant |
| | | |
|
value:
|
value to use in operation |
| |
|
divide_constant
|
| divide each component with the value from auxiliary input |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
constant |
| | | |
|
value:
|
value to use in operation |
| |
|
forcefmt
|
| force format of data might be used if gggl makes bad decisions about automatic conversions, should not be needed, but can be used to tune a realtime critical processing graph |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
|
pixfmt:
|
pixelformat to force,.rgb8 rgba8 rgbA8, gaF, rgb16, rgbF, rgbAF, GAF, gF ... |
| |
|
gamma
|
| apply gamma correction to image (2.2 is the gamma for sRGB 0.45454545 is the reciprocal) |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
|
gamma:
|
gamma adjustment 1.0 = no adjustment |
| |
|
hflip
|
| horizontal flip of image, (mirror) |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
transform |
| | | |
| |
|
histogram
|
| calculate a 256 bin histogram for red/green/blue and lumiosity, output is an _image_ of the historgram |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
analysis |
| | | |
| |
|
hold
|
| stores a frame output for future use |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
|
| | | |
| |
|
invert
|
| inverts images, producing negative |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
| |
|
liquid
|
| interactive liquid, partially inspired by water works, but the code is probably a little different anyways. |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
interactive |
| | | |
|
pos:
|
position of liquid column |
|
speed:
|
number of iterations per frame generated |
|
width:
|
width,. of liquid column |
| |
|
luminance
|
| provides a grayscale image of the luminiance in an image |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
| |
|
mblur
|
| motion blurs image, uses a frame accumulator, and thus the frames that are output, will vary with playback rate. |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
realtime |
| | | |
|
opacity:
|
amount of information that the new frame adds to accumulator |
| |
|
median
|
| median filtering of image, a simple form of noise removal |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
noise reduction |
| | | |
|
horizontal:
|
horizontal radius of sampling |
|
vertical:
|
vertical radius of sampling |
| |
|
menu
|
| interactivity control pads, creates a menubar along the top of the frame that can be controlled from the input obstacle mask |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
interactive |
| | | |
|
action_1:
|
boolean state of button 1 |
|
action_10:
|
boolean state of button 10 |
|
action_2:
|
boolean state of button 2 |
|
action_3:
|
boolean state of button 3 |
|
action_4:
|
boolean state of button 4 |
|
action_5:
|
boolean state of button 5 |
|
action_6:
|
boolean state of button 6 |
|
action_7:
|
boolean state of button 7 |
|
action_8:
|
boolean state of button 8 |
|
action_9:
|
boolean state of button 9 |
|
actions:
|
number of entries |
|
label_1:
|
text on button 1 |
|
label_10:
|
text on button 10 |
|
label_2:
|
text on button 2 |
|
label_3:
|
text on button 3 |
|
label_4:
|
text on button 4 |
|
label_5:
|
text on button 5 |
|
label_6:
|
text on button 6 |
|
label_7:
|
text on button 7 |
|
label_8:
|
text on button 8 |
|
label_9:
|
text on button 9 |
| |
|
multiply_constant
|
| multiply each component with the value from auxiliary input |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
constant |
| | | |
|
value:
|
value to use in operation |
| |
|
nop
|
| no op, just pass image data through |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
|
| | | |
| |
|
opacity
|
| change overall opacity of image |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
opacity |
| | | |
|
level:
|
multiply alpha by this constant |
| |
|
pseudocolor
|
| show the dynamic range of a grayscale image using fake colors for different ranges,. black->blue->green->yellow->red |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
| |
|
quadtree
|
| quadtree sudivision/threshold created for 'One Direction music video' |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
filter |
| | | |
|
level:
|
thresholding level |
| |
|
rot90
|
| rotates an image 90 degrees |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
|
| | | |
| |
|
scale
|
| scale image, when scaling up bilinear interpolation is used, when scaling down no measures are taken, aliasing is likely to occur, if any of the pixel dimensions given are below 0 (the default), the relative values are used. |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
transform |
| | | |
|
height_px:
|
new height in pixels |
|
height_rel:
|
relative scaling of height 1.0 = no change |
|
width_px:
|
new width in pixels |
|
width_rel:
|
relative scaling of width 1.0 = no change |
| |
|
subtract_constant
|
| subtract each component with the value from auxiliary input |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
constant |
| | | |
|
value:
|
value to use in operation |
| |
|
threshold
|
| make all values with a luminiosity less than 'level' black, all others white |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
color |
| | | |
|
level:
|
split at which value |
| |
|
vectorscope
|
| renders a chromacity scope of the input image |
input_pads: |
1 |
| output_pads: |
1 |
| category: |
analysis |
| | | |
| |
|
add_mask
|
| add each component with the value from auxiliary input |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
mask |
| | | |
| |
|
apply_mask
|
| apply the auxiliary image to the alpha channel, if no alpha channel exists it will be assigned from the auxiliary image |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
opacity |
| | | |
| |
|
atop
|
| porter duff op atop |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
atop_reverse
|
| porter duff op atop_reverse |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
clear
|
| porter duff op clear |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
difference_mask
|
| difference each component with the value from auxiliary input |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
mask |
| | | |
| |
|
divide_mask
|
| divide each component with the value from auxiliary input |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
mask |
| | | |
| |
|
dst
|
| porter duff op dst |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
in
|
| porter duff op in |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
in_reverse
|
| porter duff op in_reverse |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
key_clean_slate
|
| extracts a grayscale matte by giving a reference background as aux input |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
mask |
| | | |
|
level:
|
threshold level, anything above this level is totally opaque |
|
smooth_range:
|
extent of grayscale (thus non full opacity), 0 for hard threshold |
| |
|
lua
|
| lua interper op for prototyping of image processing ops |
input_pads: |
3 |
| output_pads: |
1 |
| category: |
script |
| | | |
|
resource:
|
file to load lua script from, if set overrides script property |
|
script:
|
the script to interpret with lua |
|
var1:
|
lua variable |
|
var2:
|
lua variable |
|
var3:
|
lua variable |
|
var4:
|
lua variable |
| |
|
mix
|
| mixes the primary image with the auxiliary image, can be animated to become a crossfade, note that the current version blatantly expect both inputs to be of the same pixel format, something that is not always the case |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
|
| | | |
|
ratio:
|
how much of the auxiliary image is mixed in |
| |
|
multiply_mask
|
| multiply each component with the value from auxiliary input |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
mask |
| | | |
| |
|
out
|
| porter duff op out |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
out_reverse
|
| porter duff op out_reverse |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
over
|
| porter duff op over |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
src
|
| porter duff op src |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
subtract_mask
|
| subtract each component with the value from auxiliary input |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
mask |
| | | |
| |
|
transform
|
| perspective transform of auxiliary image, composited with over operator into primary image |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
compositing |
| | | |
|
x0:
|
|
|
x1:
|
|
|
x2:
|
|
|
x3:
|
|
|
y0:
|
|
|
y1:
|
|
|
y2:
|
|
|
y3:
|
|
| |
|
under
|
| porter duff op under |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
xor
|
| porter duff op xor |
input_pads: |
2 |
| output_pads: |
1 |
| category: |
porter duff |
| | | |
|
subpixel_positioning:
|
use bilinear sampling, boolean value, for placement values that set to 0, to disable subpixel positioning |
|
x:
|
Relative horizontal positioning of auxiliary input on primary, as a ratio of the width of primary |
|
y:
|
Relative vertical positioning of auxiliary input on primary, as a ratio of the height of primary |
| |
|
ycbcr2rgb
|
| generates an rgb image based on three image input_pads, y u and v, this filter could be used as a model for implementing other conversions from components to rgb,. gggl's color conversion handling should be revised before more similar filters are implemented. |
input_pads: |
3 |
| output_pads: |
1 |
| category: |
color |
| | | |
| |