User defined script functions

Definition and Structure

You can define and call your own (user defined) functions in AviSynth scripts. These are independent blocks of script code that are executed each time a call to the function is made in the script. They can return any clip or variable type. An example of a simple user defined script function (here a custom filter, ie a function returning a clip) immediately follows:

function MuteRange(clip c, int fstart, int fend)
{
    before = c.Trim(0, -fstart)
    current = c.Trim(fstart, fend) 
    after = c.Trim(fend + 1, 0)
    audio = Dissolve(before, current.BlankClip, after, 3)
    return AudioDub(c, audio)
}

User defined script functions start with the keyword function, followed by the function name. The name of a script function follows the same naming rules as script variables.

Immediately after the name, the function's argument list follows. The list (which can be empty) consists of (expected argument's type - argument's name) pairs. Argument type may be any of those supported by the scripting language.

function MuteRange(clip c, int fstart, int fend)

Then comes the function body, ie the code that is executed each time the function is called. The arguments are accessed within the function body by their names. The function body is contained within an opening and closing brace pair { ... }.

{
    before = c.Trim(0, -fstart)
    current = c.Trim(fstart, fend) 
    after = c.Trim(fend + 1, 0)
    audio = Dissolve(before, current.BlankClip, after, 3)
    return AudioDub(c, audio)
}

For simplicity, this code assumes the function will only be called with fstart>0 and fend<c.Framecount-1. A more complete version would also handle the special cases fstart=0 and fend=c.Framecount-1.

At the end of the function body, a return statement is placed, which sets the return value.

    return AudioDub(c, audio)

As a shorthand, a bare expression as the final statement is treated as if the keyword return was present. Thus, we could also have written simply

    AudioDub(c, audio)

It should be noted that unlike other languages, where multiple return statements are allowed inside the function body, AviSynth functions contain a single return statement. This is because the language does not support loops or branching in the normal sense, although there are ways around this – see Control structures for more.

Facts about user defined script functions

• Functions can take up to sixty arguments and the return value can be of any type supported by the scripting language (clip, int, float, bool, string).

• Although not recommended practice, an argument type may be omitted, and will default to val, the generic type.

• If the function expects a video clip as its first argument, and that argument is not supplied, then the clip in the special Last variable will be used.

• Functions support named arguments. Simply enclose an argument's name inside double quotes to make it a named argument. Note that after doing so the following apply:
  1. All subsequent arguments in the argument list must be named also.
  2. A named argument is an optional argument, that is, it need not be supplied by the caller.
  3. When a function is called, any optional argument which has not been provided is set to a value which has the void ('undefined') type. This does not mean that its value is random garbage - simply that its type is neither clip, int, float, bool or string and so it has no usable value.
  4. Normally, you should use the Defined function to test if an optional argument has an explicit value, or the Default function, which combines the Defined test with the setting of a default value if appropriate.
  5. A void ('undefined') value can be passed on to another function as one of its optional arguments. This is useful when you want to write a wrapper function that calls another function, preserving the same defaults.

• If a function body has no (explicit or implicit) return, a void value (ie a value of the 'undefined' type) is returned.

• Functions always produce a new value and never modify an existing one. What that means is that all arguments to a function are passed "by value" and not "by reference"; in order to alter a variable's value in AviSynth script language you must assign to it a new value.

• Functions can call other functions, including themselves. The latter is known as recursion and is a very useful technique for creating functions that can accomplish complex tasks. See Control structures for more.

• Local function variables mask global ones with the same name inside the function body. For example, if you define in a function a local variable myvar by assigning to it a value, then you cannot read the global myvar anymore inside this function.

• The above is also true for arguments, since from the perspective of a function arguments are initialized local variables.

• Each function has its own local version of the special variable Last. On entry to a function, Last is set to a void ('undefined') value.

Related Links

• Shared functions – an ever growing collection of shared script functions created by the members of the AviSynth community.
• Category:Scripts – even more scripts.

TODO

http://www.avisynth.org/ExportingSingleImage

http://www.avisynth.org/HowToApplyFilterToManySingleFrames

Perhaps make decent functions from the last two?