Editing Internal functions

<div style="max-width:82em; min-width:42em;" >
<div style="max-width:64em" >
In addition to [[Internal_filters|internal filters]] AviSynth has a fairly large number of other (non-clip) internal functions. 

The input or/and output of these functions are not clips, but some other variables which can be used in a script. 
{| style="max-width:56em"
|-
| style="vertical-align:top;" |
<div style="margin:1.0em;padding:2px 8px;">
<div style="border:1px solid #aaa; background-color:#f9f9f9; padding:5px; font-size:95%; width:20em">
<div style="margin=auto;text-align:center">'''Short Contents:'''</div>
# [[#Boolean_functions|Boolean functions]]
# [[#Control_functions|Control functions]]
# [[#Global_options|Global options]]
# [[#Conversion_functions|Conversion functions]]
# [[#Numeric_functions|Numeric functions]]
# [[#Trigonometry_functions|Trigonometry functions]]
# [[#Bit_functions|Bit functions]]
# [[#Runtime_functions|Runtime functions]]
# [[#Runtime_functions_for_frame_properties|Runtime functions for frame properties]]
# [[#Script_functions|Script functions]]
# [[#String_functions|String functions]]
# [[#Version_functions|Version functions]]
# [[#Other_helper_functions|Other helper functions]]
<div style="line-height:50%;margin:0;padding:0">&nbsp;</div>
</div>
</div>
| style="width:4em;" |&nbsp;
| style="vertical-align:top;" |
<div>
<div style="float:right;clear:right;margin:1.0em;padding:2px 8px;">
__TOC__
</div>
</div>
|}
</div>

== Boolean functions ==
<div style="max-width:62em" >
: These return true or false, if the condition that they test holds or not, respectively.

{{ScriptFunctionH5|IsBool||IsBool(var)}}
: Tests if {{FuncArg|var}} is of the bool type. {{FuncArg|var}} can be any expression allowed by the [[AviSynth Syntax]].
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 b = false
 IsBool(b) = true
 IsBool(1 < 2 && 0 == 1) = true
 IsBool(123) = false
</div>

{{ScriptFunctionH5|IsClip||IsClip(var)}}
: Tests if {{FuncArg|var}} is of the clip type. {{FuncArg|var}} can be any expression allowed by the [[AviSynth Syntax]].
''Examples:''
<div {{BoxWidthIndent|56|2}} >

 c = [[AviSource]](...)
 IsClip(c) = true
 IsClip("c") = false
</div>

{{ScriptFunctionH5|IsFloat||IsFloat(var)}}
: Tests if {{FuncArg|var}} is of the float type. {{FuncArg|var}} can be any expression allowed by the [[AviSynth Syntax]].
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 f = [[Internal_functions/Numeric_functions|Sqrt]](2)
 IsFloat(f) = true
 IsFloat(true) = false
 IsFloat("42.") = false
 IsFloat(2) = true   # ''ints are considered to be floats by this function''
 IsReallyFloat(2) = false # see below
</div>
: As a workaround for the issue noted above, you may use the following [[User_functions|user function]]:
<div {{BoxWidthIndent|46|3}} >
 ## return true for floats only
 function IsReallyFloat(val v)
 {
     return (IsInt(v)==false) && IsFloat(v)
 }
</div>

{{ScriptFunctionH5|IsInt||IsInt(var)}}
: Tests if {{FuncArg|var}} is of the int type. {{FuncArg|var}} can be any expression allowed by the [[AviSynth Syntax]].
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 IsInt(2) = true
 IsInt(2.1) = false
 IsInt(true) = false
</div>

{{ScriptFunctionH5|IsString||IsString(var)}}
: Tests if {{FuncArg|var}} is of the string type. {{FuncArg|var}} can be any expression allowed by the [[AviSynth Syntax]].
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 IsString("test") = true
 IsString(2.3) = false
 IsString([[Internal_functions/Conversion_functions|String]](2.3)) = true
</div>

{{ScriptFunctionH5|Exist||Exist(filename)}}
: Tests if the file specified by {{FuncArg|filename}} exists.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 filename = ...
 clp = Exist(filename) 
 \ ? [[AviSource]](filename) 
 \ : [[Internal_functions/Control_functions|Assert]](false, "file: " + filename + " does not exist")
</div>

{{ScriptFunctionH5|Defined||Defined(var)}}
: Tests if {{FuncArg|var}} is defined. Can be used inside [[Script_functions]] to test if an optional argument has been given an explicit value.
: More formally, the function returns false if its argument (normally a function argument or variable) has the void ('undefined') type, otherwise it returns true.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 b_arg_supplied = Defined(arg)
 myvar = b_arg_supplied ? ... : ...
</div>

{{ScriptFunctionH5|FunctionExists|{{AvsPluscon}}|FunctionExists(name)}}
: Tests if the function or filter name is defined in the script.
: {{FuncArg|name}} can be any string &ndash; it does not need to be a [[Script_variables#Variable_Names|legal name]].
: ''Example'' &ndash; see [[#Apply|Apply]] below

{{ScriptFunctionH5|InternalFunctionExists|{{AvsPluscon}}|InternalFunctionExists(name)}}
: Tests if the function, filter or [[Clip_properties|property]] name is defined natively within [[AviSynth+]].
:* Unlike [[#FunctionExists|FunctionExists]], returns ''false'' for [[Plugins|external plugins]] and [[User_functions|user-defined functions]].
</div>

{{ScriptFunctionH5|VarExist|{{AvsPluscon}}|VarExist(name)}}
: Tests if the variable exists or not. Note: if variable exists, it returns true regardless of the "defined" state of the variable
</div>

== Control functions ==
<div style="max-width:62em" >
: These facilitate flow of control (loading of scripts, arguments checks, global settings adjustment, etc.).

{{ScriptFunctionH5|Apply||Apply(string ''func_string'' [, arg1 [, arg2 [, ... [, arg''n'']]]] )}}
: Calls the function or filter {{FuncArg|func_string}} with arguments {{FuncArg|arg1}}, {{FuncArg|arg2}}, ..., {{FuncArg|arg''n''}} (as many as supplied). 
:* This provides a way to call a function or filter '''by name''', with arguments.
:* <code>Apply("f", x)</code> is equivalent to <code>f(x)</code>
:* <code>Apply("f", x)</code> is equivalent to <code>[[#Eval|Eval]]("f(" + String(x) + ")")</code>
:* Note that the clip argument must be supplied explicitly - the [[Last|special variable ''Last'']] is not used.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 ## Building an expression dynamically  
 new_width = 352
 new_height = 288
 
 Apply("[[BicubicResize]]", Last, new_width, new_height)
 # Note that the clip argument must be supplied - 'Last' is not implicitly assumed
 
 ## the same action, using [[#Eval|Eval]]
 Eval( "BicubicResize(" + String(new_width) + "," + String(new_height) + ")" )
</div>

<div {{BoxWidthIndent|56|2}} >
 ## using a filter only if it exists (AviSynth 2.6)
 function MyFilter(clip C, string s) { 
     return C.[[Subtitle]]("MyFilter: "+s, align=5)
 }
 ColorBars 
 [[Control_structures|try]] {
     Apply("MyFilter", Last, "TEST")
 } catch (err_msg) {
     # (ignore)
 }
 return Last
</div>

<div {{BoxWidthIndent|56|2}} >
 ## using a filter only if it exists ([[AviSynth+|AVS+]] only)
 ColorBars  
 return [[#FunctionExists|FunctionExists]]("MyFilter") 
 \ ? Apply("MyFilter", Last, "TEST") 
 \ : Last 
</div>

{{ScriptFunctionH5|Eval||Eval(expression [, string ''name''])}}
: Evaluates an arbitrary {{FuncArg|expression}} and returns the result of that evaluation. '''It works exactly like [[#Import|Import]] below''', except
:* The expression to be evaluated comes from a string instead of a file; 
:* The [[#Script_functions|values of]] ''ScriptName'', ''ScriptFile'' and ''ScriptDir'' are not changed;
:* The current working directory ([[wikipedia:Working_directory|CWD]]) is not changed.
: Argument {{FuncArg|name}} will be shown in the error message beside the script name. Both will be followed with the line number in {{FuncArg|expression}} where the error occurred.

: Variables in your calling script are available within {{FuncArg|expression}}; [[Global|global variables]] are not required.
: Note '''Eval''' can return the result of ''any'' valid expression; usually a clip, but also a string, boolean etc.
: You can use '''Eval''' to construct and evaluate expressions dynamically inside your scripts, based on variable input data.
: '''Eval''' is useful as a [[Control_structures|control structure]] for creating multi-line ''block statements'' without requiring [[AviSynth%2B|AviSynth+]].
: '''Eval''' can be used to put aside the need to install external plugins if they are not actually used.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 ## Building an expression dynamically 
 ## calls [[BicubicResize]](last, 352, 288)
 settings = "352, 288"
 Eval( "BicubicResize(" + settings + ")" )
</div>
 
<div {{BoxWidthIndent|56|2}} >
 ## if...else [[Control_structures|control structure]]
 option = true
 option  
 \ ? '''Eval'''("""
     [[Levels]](0, 1.2, 255, 20, 235)
     [[Spline36Resize]](720, 400)
     [[Sharpen]](0.2)
 """) 
 \ : '''Eval'''("""
     [[BicubicResize]](720, 400)
     [[Sharpen]](0.3)
 """)
</div>

<div {{BoxWidthIndent|56|2}} >
 ## using a filter only if it is needed; 
 ## in this example, [[SMDegrain]] only needs to be installed if the option is ''true''.
 option = false
 option 
 \ ? '''Eval'''("""
     SMDegrain(tr=2, thSAD=250, contrasharp=true, refinemotion=true, lsb=true)
 """)
 \ : Last 
</div>

<div {{BoxWidthIndent|56|2}} >
 ## accessing script variables
 ColorBars
 A=[[Subtitle]]("A", align=5)
 '''Eval'''("A")
 return Last ## returns clip 'A'
</div>

<div {{BoxWidthIndent|56|2}} >
 ## setting script variables
 ColorBars
 A=Subtitle("A", align=5)
 '''Eval'''("B = A.Invert")
 return B ## returns clip 'A' with colors inverted
</div>

<div {{BoxWidthIndent|56|2}} >
 ## Increment a global variable, based on a local variable
 Eval("global my_counter = my_counter + " + [[#String|String]](increment)) 
</div>

<div {{BoxWidthIndent|56|2}} >
 ## multi-line example with comment and line continuation
 '''Eval'''("""
 [[ColorBars]]
 [[BicubicResize]](352, 288)
 #FlipVertical
 Subtitle(
 \   "Width  = "  + [[#String|String]]([[Clip_properties|Width]]) + "\n"
 \ + "Height = " + String(Height)
 \ , align=7, lsp=0)
 """)
</div>

<div {{BoxWidthIndent|56|2}} >
 ## Empty expression 
 ## results in error: 'Defined(u) == false'
 u = Eval("#")   
</div>

<div {{BoxWidthIndent|56|2}} >
 ## Error reporting
 ColorBars
 A=Subtitle("A", size=Height, align=2)
 Eval("""
 A
 foo("bar") ## ERROR!
 """, '''"eval_test_1"''') ## name for error reporting purposes
 return Last
 
 ''results in the error message:''
 Script error: there is no function named "foo"
 '''(eval_test_1, line 3)'''
 (E:\_test.avs, line 6)
</div>

{{ScriptFunctionH5|Import||Import(filename)}}
{{ScriptFunctionCode|Import||Import(filename [, ...] [, bool utf8])}} {{AvsPluscon}}
: Evaluates the contents of another script and returns the result of that evaluation. '''It works exactly like [[#Eval|Eval]] above''', except
:* The expression to be evaluated comes from a file instead of a string; 
:* The [[#Script_functions|values of]] ''ScriptName'', ''ScriptFile'' and ''ScriptDir'' are set to the current (imported) script;
:* The current working directory ([[wikipedia:Working_directory|CWD]]) is [[Internal_functions#SetWorkingDir|set]] to the current (imported) script.
:* {{FuncArg|utf8}} {{AvsPluscon}} if true, assumes filename(s) are [[wikipedia:UTF-8|UTF8]], else (default), assume ANSI.

:[[Script_functions|Functions]], [[Script_variables|variables]] and loaded plugins declared inside the imported script are made available to the parent script. <b>Import</b>'s return value  can be assigned to a variable of the parent script; this is most useful when the imported script ends with a clip.

: Typically '''Import''' is used to make library functions available to the parent script, and the return value is not used. However this is simply a convention; it is not enforced by the [[AviSynth Syntax]]. Some indicative uses of '''Import''' include:
:* Storing multiple script-functions, variables and global variables for reuse by scripts (creation of script libraries).
:* Retrieving pre-built streams.
:* Retrieving dynamically configured pre-built streams (the core idea is that the importing script declares some global variables which the imported script uses to configure the stream that will return).
:'''Note 1''': Since the contents of the imported script are evaluated at the point of invocation, it is possible by enclosing the '''Import''' call in a nested scope (for example inside a function) to make available to the importing script the functions and globals of the imported script ''without'' its script-level variables.
:'''Note 2''': Any script with the [[AVSI]] extension in the AviSynth Plugins folder is automatically imported. This is useful for making script functions available to any new script you create without having to copy and paste.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 # ''B.avsi''
 A.Invert
</div><div {{BoxWidthIndent|56|2}} >
 ColorBars
 A=Subtitle("A", align=5) ## create clip 'A'
 Import("B.avsi")
 return Last ## returns clip 'A' with colors inverted
</div>

<div {{BoxWidthIndent|56|2}} >
 ## here we do not care about the return value (''mylib.avsi'' contains only functions)
 Import("mylib.avsi")  
 ...
 ## ''mysources.avsi'' loads predetermined file names from a folder into globals
 okflag = Import("mysources.avsi")  
 source = okflag ? global1 + global2 + global3 : [[BlankClip]]()
</div>

{{ScriptFunctionH5|Select||Select(index, item0 [, item1 [, ...[, itemn]]])}}
: Returns the item selected by the {{FuncArg|index}} argument, which must be of int type (0 returns {{FuncArg|item0}}, 1 returns {{FuncArg|item1}}, ..., etc). Items can be any script [[Script_variables|variable]] or expression of any type and can even be mixed.

:If {{FuncArg|index}} is out of range, an error is raised.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 # select a clip-brush from a set of presets
 idx = 2
 brush = Select(idx, [[AviSource]]("round.avi"), 
 \        rectangle, diagonal, diagonal.[[FlipHorizontal]])
</div>

Note - all branches are evaluated:
<div {{BoxWidthIndent|56|2}} >
 index=1
 Select(index, "zero", "one", "two", 
 \        Assert(false, "Select evaluates all branches")) 
 ## NOTE this code does not run - it throws [[#Assert|Assert]] error
 ## because Select evaluates all branches
</div>

If this is not desired, use the [[Ternary_operator|conditional execution]] operator: 
<div {{BoxWidthIndent|56|2}} >
 index=1
 x = (index==0) ? "zero"
 \ : (index==1) ? "one"
 \ : (index==2) ? "two"
 \ : Assert(false, "index out of range")
</div>

{{ScriptFunctionH5|Default||Default(x, d)}}
: Returns {{FuncArg|x}} if '''Defined'''(x) is true, {{FuncArg|d}} otherwise. {{FuncArg|x}} must either be a function's argument or an already declared script variable (ie a variable which has been assigned a value) else an error will occur.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 function myfunc(clip c, ..., int "strength") {
     ...
     strength = Default(strength, 4) # if not supplied make it 4
     ...
 }
</div>

{{ScriptFunctionH5|Assert||Assert(condition [, err_msg])}}
: Does nothing if {{FuncArg|condition}} is true; throws an error, immediately terminating script execution, if {{FuncArg|condition}} is false. In the later case {{FuncArg|err_msg}}, if supplied, is presented to the user through a dialog box; else the standard message "Assert: assertion failed" shows up.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 function myfunc(clip c, ..., int "strength") {
     ...
     strength = Default(strength, 4) # if not supplied make it 4
     Assert(strength > 0, "'strength' must be positive")
     ...
 }
</div>

{{ScriptFunctionH5|NOP||NOP()}}
: This is a no-operation function provided mainly for conditional execution with non-return value items such as [[Import]], when no "else" condition is desired. That is, use it whenever the [[AviSynth Syntax]] requires an operation (such as with the ?: [[Operators#For_Booleans|operator]]) but your script does not need one.
: Return value: 0 (int type).
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 preset = want_presets ? [[AviSource]]("c:\presets\any.avi") : NOP
 ... 
 loadlib ? [[Import]]("my_useful_functions.avs") : NOP
</div>

{{ScriptFunctionH5|Undefined|v2.60|Undefined()}}
: Returns the undefined state.
: It's the state for which '''Defined'''() returns false.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 x = Undefined()
 Defined(x) # == false
</div>
</div>


== Global Options ==
<div style="max-width:62em" >
{{ScriptFunctionH5|SetMemoryMax||SetMemoryMax(amount)}}
: Sets the maximum memory that AviSynth uses (in MB) to the value of {{FuncArg|amount}}. Setting to zero just returns the current Memory Max value. In the 2.5 series the default Memory Max value is 25% of the free physical memory, with a minimum of 16MB.
: The default Memory Max is also limited to 512MB.
: In Avisynth+ this limit for default Memory Max is 1024MB for 32 bits and 4096MB on the x64 version
: DefaultMemoryMax = minimum(physical_memory / 4, secondary_memory_max_limit)
: for classic Avisynth see the table below
:{|class="wikitable" <!-- width=50% -->
 |-
 | Free memory
 | <64
 | 128
 | 256
 | 512
 | 1024
 | 2048
 | 3072
 |-
 | Default Max
 | 16
 | 32
 | 64
 | 192
 | 448
 | 512
 | 512
 |}
: In some versions there is a default setting of 5MB, which is quite low. If you encounter problems (e.g. low speed) try to set this values to at least 32MB. Too high values can result in crashes because of 2GB address space limit.
: Return value: Actual MemoryMax value set.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 SetMemoryMax(128)
</div>

<div style="max-width:62em" >
{{ScriptFunctionH5|SetCacheMode||SetCacheMode(mode)}}
:{{AvsPluscon}}Fine tunes the internal frame caching strategy in AviSynth+.
: Available values:
::* 0 or CACHE_FAST_START start up time and size balanced mode (default)
::* 1 or CACHE_OPTIMAL_SIZE slow start up but optimal speed and cache size
::
* since Avisynth+ 3.6.1

<div style="max-width:62em" >
{{ScriptFunctionH5|SetMaxCPU||SetMaxCPU([string feature1, string feature2, ...])}}
: {{AvsPluscon}}Limits the CPU capabilities which AviSynth reports to its core and external plugins through GetCPUFlags.
: Available values:
::* "" or "none" for zero SIMD support, no processor flags are reported
::* "mmx", "sse", "sse2", "sse3", "ssse3", "sse4" or "sse4.1", "sse4.2", "avx, "avx2"
:: 
::Parameters are case insensitive.
::Note: "avx2" triggers FMA3 flag as well.
::
::*Processor options w/o any modifier will limit the CPU flag report to at most the processor level.
::*When "feature" is ended by '+', relevant processor feature flag will be switched on
::*When "feature" is ended by '-', relevant processor feature flag will be removed.
::Multiple options can be put in a comma separated list. They will evaluate in that order.
''Examples:''
<div {{BoxWidthIndent|60|2}} >
 SetMaxCPU("SSE2") #reports at most SSE2 processor (even if AVX2 is available)
 SetMaxCPU("avx,sse4.1-") #limits to avx2 but explicitely removes reporting sse4.1 support
 SetMaxCPU("none,avx2+") #limits to plain C, then switches on AVX2-only support
</div>
* since Avisynth+ 3.6

{{ScriptFunctionH5|SetWorkingDir||SetWorkingDir(path)}}
: Sets the default directory for AviSynth to the {{FuncArg|path}} argument.
: This is primarily for easy loading of source clips, [[Import|importing]] scripts, etc. It does not affect plugins' autoloading. 
: Return value is 0 if successful, -1 otherwise.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 SetWorkingDir("c:\my_presets")
 [[AviSource]]("border_mask.avi")  # this loads c:\my_presets\border_mask.avi
</div>

{{ScriptFunctionH5|SetPlanarLegacyAlignment||SetPlanarLegacyAlignment(mode)}}
: Set alignment mode for [[planar]] frames. {{FuncArg|mode}} can either be true or false.
: Some older [[External_plugins|plugins]] illegally assume the layout of video frames in memory. This special filter forces the memory layout of planar frames to be compatible with prior versions of AviSynth. The filter works on the [[The_script_execution_model/Evaluation_of_runtime_scripts|GetFrame]]() call stack, so it effects filters '''before''' it in the script.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Example : Using an older version of Mpeg2Source() (1.10 or older):
 
 LoadPlugin("...\Mpeg2Decode.dll")
 Mpeg2Source("test.d2v")         # A plugin that illegally assumes the layout of memory
 SetPlanarLegacyAlignment(true)  # Set legacy memory alignment for prior statements
 [[Convert|ConvertToYUY2]]()     # Statements through to the end of the script have
 ...                             # advanced memory alignment.
</div>

{{ScriptFunctionH5|OPT_AllowFloatAudio||global OPT_AllowFloatAudio &#61; true ## default false}}
: [[Float]] audio is converted to 16 bit when [[Frameserver|frameserving]] through [[ACM]], unless [[Internal_functions#OPT_AllowFloatAudio|OPT_AllowFloatAudio]] is set to true (this option enables WAVE_FORMAT_IEEE_FLOAT audio output<sup>[http://forum.doom9.org/showthread.php?t=109608]</sup>). In that case the audio is kept as it is. When accessing AviSynth directly (like MeGUI, BeHappy or ffmpeg do for example), there is no automatic conversion.

:The automatic conversion is done for clients that cannot handle [[Float]] audio (in the old days most of them couldn't). Note conversion takes place ''after'' the script processing is finished. [[Float]] audio is always allowed within the script.<br>

{{ScriptFunctionH5|OPT_UseWaveExtensible||global OPT_UseWaveExtensible &#61; true ## default false}}
: This option enables WAVE_FORMAT_EXTENSIBLE audio output. The default is WAVE_FORMAT_EX.
: '''Note:''' The default DirectShow component for .AVS files, "AVI/WAV File Source", does not correctly implement WAVE_FORMAT_EXTENSIBLE processing, so many application may not be able to detect the audio track. There are third party DirectShow readers that do work correctly. Intermediate work files written using the AVIFile interface for later DirectShow processing will work correctly if they use the DirectShow "File Source (async)" component or equivalent. 

{{ScriptFunctionH5|OPT_dwChannelMask|v2.60|global OPT_dwChannelMask(int v)}}
: This option enables you to set ChannelMask. It overrides WAVEFORMATEXTENSIBLE.dwChannelMask<sup>[[http://wiki.multimedia.cx/index.php?title=WAVEFORMATEXTENSIBLE]</sup> which is set according to this table
<div {{BoxWidthIndent|56|2}} >
 0x00004, // 1   -- -- Cf
 0x00003, // 2   Lf Rf
 0x00007, // 3   Lf Rf Cf
 0x00033, // 4   Lf Rf -- -- Lr Rr
 0x00037, // 5   Lf Rf Cf -- Lr Rr
 0x0003F, // 5.1 Lf Rf Cf Sw Lr Rr
 0x0013F, // 6.1 Lf Rf Cf Sw Lr Rr -- -- Cr
 0x0063F, // 7.1 Lf Rf Cf Sw Lr Rr -- -- -- Ls Rs
</div>

{{ScriptFunctionH5|OPT_AVIPadScanlines|v2.60|global OPT_AVIPadScanlines &#61; true ## default false}}
: This option enables DWORD aligned planar padding. Default is packed aligned planar padding. See [[AVIFile output emulation|memory alignment used in the AVIFile output emulation]].<br>

{{ScriptFunctionH5|OPT_VDubPlanarHack|v2.60|global OPT_VDubPlanarHack &#61; true ## default false}}
: This option enables flipped YV24 and YV16 chroma planes. This is an hack for early versions of Virtualdub with YV24/YV16 support. <br>

{{ScriptFunctionH5|OPT_Enable_V210|{{AvsPluscon}}|global OPT_Enable_V210 &#61; true ## default false}}
: For 10bit YUV422, [[Frameserver|Frameserve]] interleaved V210 instead of planar P210. (VfW)
<div {{BoxWidthIndent|56|2}} >
{{BoldColor|black|100|§}} ''VfW'' here means [[wikipedia:Video_for_Windows|Video For Windows]] clients such as VirtualDub are affected, but not other clients such as ffmpeg.
</div>

{{ScriptFunctionH5|OPT_Enable_Y3_10_10|{{AvsPluscon}}|global OPT_Enable_Y3_10_10 &#61; true ## default false}}
: For 10bit YUV422, set the [[FourCC]] to Y3[10][10] ('Y', '3', 10, 10) instead of P210  ('P', '2', '1', '0'). (VfW) <br>

{{ScriptFunctionH5|OPT_Enable_Y3_10_16|{{AvsPluscon}}|global OPT_Enable_Y3_10_16 &#61; true ## default false}}
: For 16bit YUV422, use Y3[10][16] instead of P216 (VfW)<br>

{{ScriptFunctionH5|OPT_Enable_b64a|{{AvsPluscon}}|global OPT_Enable_b64a &#61; true ## default false}}
: Use b64a instead of BRA[64] (VfW)
: works for avs+ version above r2636<br>

{{ScriptFunctionH5|OPT_Enable_PlanarToPackedRGB|{{AvsPluscon}}|global OPT_Enable_PlanarToPackedRGB &#61; true ## default false}}
: Convert Planar RGB to packed RGB (VfW)
: Planar RGB 8, 10, 12, 14 and 16 bits are reported as G3[0][8], G3[0][10], G3[0][12], G3[0][14] and G3[0][16]
: Planar RGBA 8, 10, 12, 14 and 16 bits are reported as G4[0][8], G4[0][10], G4[0][12], G4[0][14] and G4[0][16]
: When these [[FourCC]] codes are not handled through VfW, use OPT_Enable_PlanarToPackedRGB=true.
: Avisynth+ will convert the clip from planar to RGB64 (packed 16bit RGB) and will negotiate this format instead<br>
</div>

== Conversion functions ==
<div style="max-width:62em" >
: These convert between different types.

{{ScriptFunctionH5|Value||Value(string)}}
: Converts a decimal string to its associated numeric value.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Value ("-2.7") = -2.7
</div>

{{ScriptFunctionH5|HexValue||HexValue(string)}}
{{ScriptFunctionCode|HexValue||HexValue(string [, int pos])}} {{AvsPluscon}}
: Converts a hexadecimal string to its associated numeric value. 
:* {{FuncArg|pos}} sets the starting point of the numeric parser. All characters to the left of {{FuncArg|pos}} are ignored. Default is 1 (start of string).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 HexValue ("FF00") = 65280
</div>

{{ScriptFunctionH5|Hex|v2.60|Hex(int)}}
{{ScriptFunctionCode|Hex||Hex(int [, int width])}} {{AvsPluscon}}
: Converts a numerical value to its hexadecimal value. See [[Colors]] for more information on specifying colors.
:* {{FuncArg|width}} sets the minimum width of the returned string. 
::Resulting string will be left-padded with zeroes as needed. Allowed range is 0..8; default is 0.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Hex (10824234) = "A52A2A"
 Hex (15 width=2) = "0F"
</div>

{{ScriptFunctionH5|String||String(var [, string format_string])}}
: Converts a variable to a string. ''String'' arguments are passed along unchanged; ''bools'' are converted to "true" or "false"; numbers are formatted as described below; other [[Script_variables#Variable_Types|variable types]] (''clip'', ''val'') are converted to the empty string. 
:The syntax of {{FuncArg|format_string}} is as follows:
::<code>'''%'''[flags][width][.precision]'''f'''</code> &nbsp;&nbsp;&nbsp;<i>the leading </i>'<tt>%</tt>'<i> and trailing </i>'<tt>f</tt>'<i> are required.</i>
:The parts of {{FuncArg|format_string}} are:
:; ''flags'' 
::{| class=wikitable
|style="text-align:center"|<tt>-</tt>
|left align (right align by default)
|-
|style="text-align:center"|<tt>+</tt>
|always print the +/- sign (show only '<tt>+</tt>' by default)
|-
|style="text-align:center"|<tt>0</tt>
|pad (see ''width'') with leading zeroes (pad with spaces by default)&nbsp;
|-
|style="text-align:center"|&nbsp;'<tt> </tt>'&nbsp;
|print a blank instead of a '<tt>+</tt>'
|-
|style="text-align:center"|<tt>#</tt>
|always print the decimal point (dropped by default if there are no decimal digits)&nbsp;
|}
:; ''width''
:: the minimum width (the string is never truncated if it is wider than ''width'')
:; ''precision''
:: the number of decimal digits
: You can also put arbitrary text around {{FuncArg|format_string}}, similar to the C-language [http://www.tutorialspoint.com/c_standard_library/c_function_sprintf.htm sprintf] function.

''Examples:''
<div {{BoxWidthIndent|62|2}} >
 Subtitle( String(1.23) )                    # '1.230000' (six decimals by default for floats)
 Subtitle( String(123) )                     # '123'      (no decimals by default for ints)
 
 Subtitle( String(1.23, "%0.2f" ))           # '1.23'
 Subtitle( String(1.23, "%0.1f" ))           # '1.2'
 Subtitle( String(1.23, "%5.1f") )           # '  1.2'    (padded to 5 characters wide)
 Subtitle( String(1.23, "%1.3f") )           # '1.230'    (3 decimals; add trailing zeroes)
 
 Subtitle( String(123, "%0.0f") )            # '123'      (no decimals for precision=0)
 Subtitle( String(123, "%''#''0.0f") )           # '123.'     ('#' flag: always show decimal point)
 Subtitle( String(123, "%0.2f") )            # '123.00'   (2 decimals: add trailing zeroes)
 Subtitle( String(123, "%5.0f") )            # '  123'    (padded to 5 characters wide using ' ')
 Subtitle( String(123, "%05.0f") )           # '00123'    (padded to 5 characters wide using '0')
 
 Subtitle( String(PI, "PI=%0.0f") )          # 'PI=3'     (text around format_string)
 Subtitle( String(PI, "PI=%''#''0.0f") )         # 'PI=3.'    ('#' flag: always show decimal point)
 Subtitle( String(PI, "PI=%2.0f") )          # 'PI= 3'
 Subtitle( String(PI, "PI=%3.2f") )          # 'PI=3.14'
 Subtitle( String(PI, "PI=%0.5f") )          # 'PI=3.14159'
 Subtitle( String(PI, "PI=%6.3f") )          # 'PI= 3.142'
 
 Subtitle( String(32, "%0.0f") )             # '32'
 Subtitle( String(32, "%3.0f") )             # ' 32'
 Subtitle( String(32, "%8.0f") )             # '      32'
 
 ## arbitrary text around format_string:
 Subtitle( String(Last.Height, "Clip height is %0.0f") ) # 'Clip height is 480'
 ## same output as above but using string concatenation:
 Subtitle( "Clip height is " + String(Last.Height) )
</div>
</div>


== Numeric functions ==
<div style="max-width:62em" >
: These provide common mathematical operations on numeric variables.

{{ScriptFunctionH5|Max||Max(float, float [, ...])}}
: Returns the maximum value of a set of numbers.
: If all the values are of type Int, the result is an Int. If any of the values are of type Float, the result is a Float.
: This may cause an unexpected result when an Int value greater than 16777216 is mixed with Float values.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Max (1, 2) = 2
 Max (5, 3.0, 2) = 5.0
</div>

{{ScriptFunctionH5|Min||Min(float, float [, ...])}}
: Returns the minimum value of a set of numbers.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Min (1, 2) = 1
 Min (5, 3.0, 2) = 2.0
</div>

{{ScriptFunctionH5|MulDiv||MulDiv(int, int, int)}}
: Multiplies two ints (m, n) and divides the product by a third (d) in a single operation, with 64 bit intermediate result. The actual equation used is <tt> (m * n + d / 2) / d </tt>.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 MulDiv (1, 1, 2) = 1
 MulDiv (2, 3, 2) = 3
</div>

{{ScriptFunctionH5|Floor||Floor(float)}}
: Converts from single-precision, [http://en.wikipedia.org/wiki/Floating_point floating-point] value to int (round down on any fractional amount).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Floor(1.2) = 1
 Floor(1.6) = 1
 Floor(-1.2) = -2
 Floor(-1.6) = -2
</div>

{{ScriptFunctionH5|Ceil||Ceil(float)}}
: Converts from single-precision, [http://en.wikipedia.org/wiki/Floating_point floating-point] value to int (round up on any fractional amount).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Ceil(1.2) = 2
 Ceil(1.6) = 2
 Ceil(-1.2) = -1
 Ceil(-1.6) = -1
</div>

{{ScriptFunctionH5|Round||Round(float)}}
: Converts from single-precision, [http://en.wikipedia.org/wiki/Floating_point floating-point] value to int (round off to nearest integer).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Round(1.2) = 1
 Round(1.6) = 2
 Round(-1.2) = -1
 Round(-1.6) = -2
</div>

{{ScriptFunctionH5|Int||Int(float)}}
: Converts from single-precision, [http://en.wikipedia.org/wiki/Floating_point floating-point] value to int (round towards zero).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Int(1.2) = 1
 Int(1.6) = 1
 Int(-1.2) = -1
 Int(-1.6) = -1
</div>

{{ScriptFunctionH5|Float||Float(int)}}
: Converts int to single-precision, [http://en.wikipedia.org/wiki/Floating_point floating-point] value. Integer values that require more than 24-bits to be represented will have their lower 8-bits truncated yielding unexpected values.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Float(4) = 4.0
 Float(4) / 3 = 1.333 (while 4 / 3 = 1 , due to integer division)
 Float(123456789) = 123456792.0 (error = -3, 0.000002%)
 Float(1234567890) = 1234567936.0 (error = -46, 0.000004%)
</div>

{{ScriptFunctionH5|Fmod|v2.60|Fmod(float, float)}}
: Returns the modulo of the argument. Output is float.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Fmod(3.5, 0.5) = 0 (since 3.5 - 7*0.5 = 0)
 Fmod(3.5, 1.0) = 0.5 (since 3.5 - 3*1.0 = 0.5)
</div>

{{ScriptFunctionH5|Pi||Pi()}}
: Returns the value of the {{BoldColor|black|110|π}} constant (the ratio of a circle's circumference to its diameter).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 d = Pi()    # d == 3.141592653
</div>

{{ScriptFunctionH5|Exp||Exp(float)}}
: Returns the natural (base-e) exponent of the argument.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Exp(1) = 2.7182818
 Exp(0) = 1.0
</div>

{{ScriptFunctionH5|Log||Log(float)}}
: Returns the natural (base-e) logarithm of the argument.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Log(1) = 0.0
 Log(10) = 2.30259
 Log(Exp(1)) = 1.0
</div>

{{ScriptFunctionH5|Log10|v2.60|Log10(float)}}
: Returns the common logarithm of the argument.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Log10(1.0) = 0
 Log10(10.0) = 1.0
 Log10(2.0) = 0.3010299957
</div>

{{ScriptFunctionH5|Pow||Pow(float base, float power)}}
: Returns {{FuncArg|base}} raised to a {{FuncArg|power}}.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Pow(2, 3) = 8
 Pow(3, 2) = 9
 Pow(3.45, 1.75) = 8.7334
</div>

{{ScriptFunctionH5|Sqrt||Sqrt(float)}}
: Returns the square root of the argument.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Sqrt(1) = 1.0
 Sqrt(2) = 1.4142
</div>

{{ScriptFunctionH5|Abs||Abs(float or int)}}
: Returns the absolute value of its argument (returns float for float, integer for integer).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Abs(-3.8) = 3.8
 Abs(-4) = 4
</div>

{{ScriptFunctionH5|Sign||Sign(float)}}
: Returns the sign of the value passed as argument (1, 0 or -1).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Sign(-3.5) = -1
 Sign(3.5) = 1
 Sign(0) = 0
</div>

{{ScriptFunctionH5|Frac||Frac(float)}}
: Returns the fractional portion of the value provided.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Frac(3.7) = 0.7
 Frac(-1.8) = -0.8
</div>

{{ScriptFunctionH5|Rand||Rand([int max] [, bool scale] [, bool seed])}}
: Returns a random integer value. All parameters are optional. 
:;max
::sets the maximum value+1 (default 32768) and can be set negative for negative results. It operates either in scaled or modulus mode (default {{FuncArg|scale}}=true only if [[#Abs|Abs]]({{FuncArg|max}}) > 32768, false otherwise). 
:;scale
::When true, ''scales'' the internal random number generator value to the maximum value, while ''modulus mode'' ({{FuncArg|scale}}=false) uses the remainder from an integer divide of the random generator value by the maximum. Modulus mode is recommended for smaller maximums. 
:;seed
::When true, seeds the random number generator with the current time. {{FuncArg|seed}} defaults to false and probably isn't necessary, although it's there just in case. 
: Typically, this function would be used with the [[#Select|'''Select''']] function for random clips. 

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Select(Rand(5), clip1, clip2, clip3, clip4, clip5)
</div>

{{ScriptFunctionH5|Spline||Spline(float X, x1, y1, x2, y2, .... [, bool cubic])}}
: Interpolates the Y value at point X using the control points {{FuncArg|x1}}/{{FuncArg|y1}}, ... There have to be at least 2 x/y-pairs. The interpolation can be {{FuncArg|cubic}} (the result is a spline) or linear (the result is a polygon). Default is cubic.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Spline(5, 0, 0, 10, 10, 20, 0, false) = 5
 Spline(5, 0, 0, 10, 10, 20, 0, true) = 7
</div>

===== Continued Numerator, Denominator =====
{{ScriptFunctionCode|ContinuedNumerator|v2.60|ContinuedNumerator(float, int limit)}}
{{ScriptFunctionCode|ContinuedNumerator|v2.60|ContinuedNumerator(int, int, int limit)}}
{{ScriptFunctionCode|ContinuedDenominator|v2.60|ContinuedDenominator(float, int limit)}}
{{ScriptFunctionCode|ContinuedDenominator|v2.60|ContinuedDenominator(int, int, int limit)}}
: The rational pair ('''ContinuedNumerator''', '''ContinuedDenominator''') returned has the smallest possible denominator such that the absolute error is less than 1/{{FuncArg|limit}}. More information can be found on [http://en.wikipedia.org/wiki/Continued_fraction wikipedia].
: If {{FuncArg|limit}} is not specified in the Float case the rational pair returned is to the limit of the single precision floating point value. Thus (float)((double)Num/(double)Den) == V.
: In the Int case if {{FuncArg|limit}} is not specified then the normalized original values will be returned, i.e. reduced by the ''GCD'' (greatest common divisor).

''Examples:''
<div {{BoxWidthIndent|56|2}} >

 ContinuedNumerator(PI(), limit=5000]) = 355
 ContinuedDenominator(PI(), limit=5000) = 113
 
 ContinuedNumerator(PI(), limit=50]) = 22
 ContinuedDenominator(PI(), limit=50) = 7
 
 ContinuedNumerator(355, 113, limit=50]) = 22
 ContinuedDenominator(355, 113, limit=50) = 7
</div>
</div>


== Trigonometry functions ==
<div style="max-width:62em" >
: relationships involving lengths and angles of triangles. 

{{ScriptFunctionH5|Sin||Sin(float)}}
: Returns the sine of the argument (assumes it is radians).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Sin(Pi()/4) = 0.707
 Sin(Pi()/2) = 1.0
</div>

{{ScriptFunctionH5|Cos||Cos(float)}}
: Returns the cosine of the argument (assumes it is radians).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Cos(Pi()/4) = 0.707
 Cos(Pi()/2) = 0.0
</div>

{{ScriptFunctionH5|Tan|v2.60|Tan(float)}}
: Returns the tangent of the argument (assumes it is radians).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Tan(Pi/4) = 1.0
 Tan(Pi/2) = not defined
</div>
: 32 bit IEEE floats do not have sufficient resolution to exactly represent
: pi/2 so AviSynth returns a large positive number for the value slightly less
: than pi/2 and a large negative value for the next possible value which is
: slightly greater than pi/2.

{{ScriptFunctionH5|Asin|v2.60|Asin(float)}}
: Returns the inverse of the sine of the argument (output is radians).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Asin(0.707) = 0.7852471634 (~ Pi/4)
 Asin(1.0) = 1.570796327 (~ Pi/2)
</div>

{{ScriptFunctionH5|Acos|v2.60|Acos(float)}}
: Returns the inverse of the cosine of the argument (output is in radians).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Acos(0.707) = 0.7852471634 (~ Pi/4)
 Acos(0.0) = 1.570796327 (~ Pi/2)
</div>

{{ScriptFunctionH5|Atan|v2.60|Atan(float)}}
: Returns the inverse of the tangent of the argument (output is in radians).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Atan(0.707) = 0.6154085176
 Atan(1.0) = 0.7853981634 (~ Pi/4)
</div>

{{ScriptFunctionH5|Atan2|v2.60|Atan2(float, float)}}
: Returns the angle between the positive x-axis of a plane and the point given by the coordinates (x, y) on it. Output is in radians. See [http://en.wikipedia.org/wiki/Atan2 wikipedia] for more information.
: y is the first argument and x is the second argument.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Atan2(1.0, 0) = 1.570796327 (~ Pi/2)
 Atan2(1.0, 1.0) = 0.7852471634 (~ Pi/4)
 Atan2(-1.0, -1.0) = -2.356194490 (~ -3Pi/4)
</div>

{{ScriptFunctionH5|Sinh|v2.60|Sinh(float)}}
: Returns the hyperbolic sine of the argument. See [http://en.wikipedia.org/wiki/Hyperbolic_function wikipedia] for more information.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Sinh(2.0) = 3.626860408
</div>

{{ScriptFunctionH5|Cosh|v2.60|Cosh(float)}}
: Returns the hyperbolic cosine of the argument.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Cosh(2.0) = 3.762195691
</div>

{{ScriptFunctionH5|Tanh|v2.60|Tanh(float)}}
: Returns the hyperbolic tangent of the argument.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Tanh(2.0) = 0.9640275801
</div>
</div>


== Bit functions ==
<div style="max-width:62em" >
: The functions are ''bitwise operators''. They manipulate individual bits within integer variables. This means that their arguments (being integers) are converted to binary numbers, the operation is performed on their bits, and the resulting binary number is converted back again.

{{ScriptFunctionH5|BitAnd|v2.60|BitAnd(int, int)}}
: Returns the bitwise AND (sets bit to 1 if both bits are 1 and sets bit to 0 otherwise).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 BitAnd(5, 6) = 4 # since 5 = 101, 6 = 110, and 101&110 = 100
</div>

{{ScriptFunctionH5|BitNot|v2.60|BitNot(int)}}
: Returns the bit-inversion (sets bit to 1 if bit is 0 and vice-versa).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 BitNOT(5) = -6 
 # since  5 = 101,  
 # and ~101 = 1111 1111 1111 1111 1111 1111 1111 1010 = -6
</div>
: Note: 1111 1111 1111 1111 1111 1111 1111 1010 
::= (2^32-1)-2^0-2^2 = 2^32-(1+2^0+2^2) 
::= (signed) -(1+2^0+2^2) = -6

{{ScriptFunctionH5|BitOr|v2.60|BitOr(int, int)}}
: Returns the bitwise inclusive OR (sets bit to 1 if one of the bits (or both) is 1 and sets bit to 0 otherwise).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 BitOr(5, 6) = 7 # since 5 = 101, 6 = 110, and 101|110 = 111
 BitOr(4, 2) = 6 # since 4 = 100, 2 = 010, and 100|010 = 110
</div>

{{ScriptFunctionH5|BitXor|v2.60|BitXor(int, int)}}
: Returns the bitwise exclusive OR (sets bit to 1 if exactly one of the bits is 1 and sets bit to 0 otherwise).

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 BitXor(5, 6) = 3 # since 5 = 101, 6 = 110, and 101^110 = 011
 BitXor(4, 2) = 6 # since 4 = 100, 2 = 010, and 100^010 = 110
</div>

===== Bit shift left =====
{{ScriptFunctionCode|BitLShift|v2.60|BitLShift(int, int)}}
{{ScriptFunctionCode|BitShl|v2.60|BitShl(int, int)}}
{{ScriptFunctionCode|BitSal|v2.60|BitSal(int, int)}}
: Shift the bits of a number to the left.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Shifts the bits of the number 5 two bits to the left:
 BitLShift(5, 2) = 20 (since 101 << 2 = 10100)
</div>

===== Bit shift right =====
{{ScriptFunctionCode|BitRShiftA|v2.60|BitRShiftA(int, int)}}
{{ScriptFunctionCode|BitRShiftS|v2.60|BitRShiftS(int, int)}}
{{ScriptFunctionCode|BitSar|v2.60|BitSar(int, int)}}
: Shift the bits of an integer to the right. (Arithmetic, Sign bit fill, Right Shift)
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Shifts the bits of the number -42 one bit to the right, treating it as signed:
 BitRShiftA(-42, 1) = -21 
 # (since 1111 1111 1111 1111 1111 1111 1101 0110 >> 1  
 #      = 1111 1111 1111 1111 1111 1111 1110 1011)
</div>

===== Bit shift right, unsigned =====
{{ScriptFunctionCode|BitRShiftL|v2.60|BitRShiftL(int, int)}}
{{ScriptFunctionCode|BitRShiftU|v2.60|BitRShiftU(int, int)}}
{{ScriptFunctionCode|BitShr|v2.60|BitShr(int, int)}}
: Shift the bits of an unsigned integer to the right. (Logical, zero fill, Right Shift)

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Shifts the bits of the number -42 one bit to the right, treating it as unsigned:
 BitRShiftL(-42, 1) = 2147483627 
 # (since 1111 1111 1111 1111 1111 1111 1101 0110 >> 1 
 #      = 0111 1111 1111 1111 1111 1111 1110 1011)
</div>
: Note: -42 = -(1+2^0+2^3+2^5) = (unsigned) (2^32-1)-(2^0+2^3+2^5) = 
::1111 1111 1111 1111 1111 1111 1101 0110

===== Bit rotate left =====
{{ScriptFunctionCode|BitLRotate|v2.60|BitLRotate(int, int)}}
{{ScriptFunctionCode|BitRol|v2.60|BitRol(int, int)}}
: Rotates the bits of an integer to the left by the number of bits specified in the second operand. For each rotation specified, the high order bit that exits from the left of the operand returns at the right to become the new low order bit.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Rotates the bits of the number -2147483642 one bit to the left:
 BitLRotate(-2147483642, 1) = 13 
 # (since 10000000000000000000000000000110 ROL 1
 #      = 00000000000000000000000000001101)
</div>

===== Bit rotate right =====
{{ScriptFunctionCode|BitRRotate|v2.60|BitRRotateL(int, int)}}
{{ScriptFunctionCode|BitRor|v2.60|BitRor(int, int)}}
: Rotates the bits of an integer to the right by the number of bits specified in the second operand. For each rotation specified, the low order bit that exits from the right of the operand returns at the left to become the new high order bit.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Rotates the bits of the number 13 one bit to the right:
 BitRRotate(13, 1) = -2147483642 
 # (since 00000000000000000000000000001101 ROR 1 
 #      = 10000000000000000000000000000110)
</div>

===== Bit test =====
{{ScriptFunctionCode|BitTest|v2.60|BitTest(int, int)}}
{{ScriptFunctionCode|BitTst|v2.60|BitTst(int, int)}}
: Tests a single bit (that is, it returns true if its state is one, else it returns false). The second operand denotes the location of the bit which is specified as an offset from the low order end of the operand (starting at zero).
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Check the state of the fourth bit:
 BitTest(3, 4) = False
 BitTest(19, 4) = True
 
 Check the state of the sign bit:
 BitTest(-1, 31) = True
 BitTest(2147483647, 31) = False
</div>

{{ScriptFunctionH5|BitSet|v2.60|BitSet(int, int)}}
: Sets a single bit to one (so it sets its state to one). The second operand denotes the location of the bit which is specified as an offset from the low order end of the operand (starting at zero).
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Set the state of the fourth bit to one:
 BitSet(3, 4) = 19
 BitSet(19, 4) = 19
 
 Set the state of the sign bit to one:
 BitSet(-1, 31) = -1
 BitSet(2147483647, 31) = -1
</div>

{{ScriptFunctionH5|BitSetCount||BitSetCount(int [, int...])}} {{AvsPluscon}}
: Returns the total number of set bits in all supplied integer arguments.

===== Bit clear =====
{{ScriptFunctionCode|BitClear|v2.60|BitClear(int, int)}}
{{ScriptFunctionCode|BitClr|v2.60|BitClr(int, int)}}
: Sets a single bit to zero (so it sets its state to zero). The second operand denotes the location of the bit which is specified as an offset from the low order end of the operand (starting at zero).
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Clear the bits of the number 5
 BitClear(5, 0) = 4 (first bit is set to zero)
 BitClear(5, 1) = 5 (second bit is already zero)
 BitClear(5, 2) = 1 (third bit is set to zero)
 BitClear(5, 3) = 5 (fourth bit is already zero)
 
 Clear the state of the sign bit:
 BitClear(-1, 31) = 2147483647
</div>

===== Bit change =====
{{ScriptFunctionCode|BitChange|v2.60|BitChange(int, int)}}
{{ScriptFunctionCode|BitChg|v2.60|BitChg(int, int)}}
: Sets a single bit to its complement (so it changes the state of a single bit; 1 becomes 0 and vice versa). The second operand denotes the location of the bit which is specified as an offset from the low order end of the operand (starting at zero). The sign bit is bit 31.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Change the state of the a bit of the number 5:
 BitChange(5, 0) = 4 (first bit is set to zero)
 BitChange(5, 1) = 7 (second bit is set to one)
 BitChange(5, 2) = 1 (third bit is set to zero)
 BitChange(5, 3) = 13 (fourth bit is set to one)
 
 Change the state of the sign bit:
 BitChange(-1, 31) = 2147483647
</div>
</div>


== Runtime functions ==
<div style="max-width:62em" >
: These are internal functions which are evaluated at every frame. They can be used inside the scripts passed to runtime filters ([[ConditionalFilter]], [[ScriptClip]], [[FrameEvaluate]]) to return information for a frame.

===== Average ===== 
{{ScriptFunctionCode|AverageLuma||AverageLuma(clip [, int offset &#61; 0])}}
{{ScriptFunctionCode|AverageChromaU||AverageChromaU(clip [, int offset &#61; 0])}}
{{ScriptFunctionCode|AverageChromaV||AverageChromaV(clip [, int offset &#61; 0])}}
{{ScriptFunctionCode|AverageB||AverageB(clip [, int offset &#61; 0])}} {{AvsPluscon}}
{{ScriptFunctionCode|AverageG||AverageG(clip [, int offset &#61; 0])}} {{AvsPluscon}}
{{ScriptFunctionCode|AverageR||AverageR(clip [, int offset &#61; 0])}} {{AvsPluscon}}
: This group of functions return a float value with the average pixel value of a plane (Luma, U-chroma and V-chroma, respectively). They require an [[ISSE]] capable cpu. In v2.61 an {{FuncArg|offset}} argument is added which enables you to access other frames than the current one.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 ScriptClip(Last, """
     threshold = 55
     luma = AverageLuma ## gives the average luma of the current frame
     #luma = AverageLuma(1) ## gives the average luma of the next frame
     luma < threshold 
     \ ? Levels(0, 1.0+0.5*(threshold-luma)/threshold, 255, 0, 255) 
     \ : last
     Subtitle("luma=" + String(luma), align=2)
 """)
</div>

===== Difference =====
{{ScriptFunctionCode|LumaDifference||LumaDifference(clip1, clip2)}}
{{ScriptFunctionCode|ChromaUDifference||ChromaUDifference(clip1, clip2)}}
{{ScriptFunctionCode|ChromaVDifference||ChromaVDifference(clip1, clip2)}}
{{ScriptFunctionCode|RGBDifference||RGBDifference(clip1, clip2)}}
{{ScriptFunctionCode|BDifference||BDifference(clip1, clip2)}} {{AvsPluscon}}
{{ScriptFunctionCode|GDifference||GDifference(clip1, clip2)}} {{AvsPluscon}}
{{ScriptFunctionCode|RDifference||RDifference(clip1, clip2)}} {{AvsPluscon}}
: This group of functions return a float value between 0 and 255 of the absolute difference between two planes from two different clips &ndash; either the combined RGB difference or the Luma, U-chroma or V-chroma differences, respectively. They require an [[ISSE]] capable cpu.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 ovl = [[Overlay]](last, mov_star, x=some_xvalue, y=some_yvalue, mask=mov_mask)
 ldif = LumaDifference(ovl) # implicit last for clip1
 udif = ChromaUDifference([[Tweak]](hue=24), ovl)
 ...
</div>

===== Difference from previous =====
{{ScriptFunctionCode|YDifferenceFromPrevious||YDifferenceFromPrevious(clip)}}
{{ScriptFunctionCode|UDifferenceFromPrevious||UDifferenceFromPrevious(clip)}}
{{ScriptFunctionCode|VDifferenceFromPrevious||VDifferenceFromPrevious(clip)}}
{{ScriptFunctionCode|RGBDifferenceFromPrevious||RGBDifferenceFromPrevious(clip)}}
{{ScriptFunctionCode|BDifferenceFromPrevious||BDifferenceFromPrevious(clip)}} {{AvsPluscon}}
{{ScriptFunctionCode|GDifferenceFromPrevious||GDifferenceFromPrevious(clip)}} {{AvsPluscon}}
{{ScriptFunctionCode|RDifferenceFromPrevious||RDifferenceFromPrevious(clip)}} {{AvsPluscon}}
: This group of functions return the absolute difference of pixel value between the current and previous frame of {{FuncArg|clip}} &ndash; either the combined RGB difference or the Luma, U-chroma or V-chroma differences, respectively.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 scene_change = (YDifferenceFromPrevious) > threshold)
 scene_change ? some_filter(...) : another_filter(...)
</div>

===== Difference to next =====
{{ScriptFunctionCode|YDifferenceToNext||YDifferenceToNext(clip [, int offset &#61; 1])}}
{{ScriptFunctionCode|UDifferenceToNext||UDifferenceToNext(clip [, int offset &#61; 1])}}
{{ScriptFunctionCode|VDifferenceToNext||VDifferenceToNext(clip [, int offset &#61; 1])}}
{{ScriptFunctionCode|RGBDifferenceToNext||RGBDifferenceToNext(clip [, int offset &#61; 1])}}
{{ScriptFunctionCode|BDifferenceToNext||BDifferenceToNext(clip [, int offset &#61; 1])}} {{AvsPluscon}}
{{ScriptFunctionCode|GDifferenceToNext||GDifferenceToNext(clip [, int offset &#61; 1])}} {{AvsPluscon}}
{{ScriptFunctionCode|RDifferenceToNext||RDifferenceToNext(clip [, int offset &#61; 1])}} {{AvsPluscon}}
: This group of functions return the absolute difference of pixel value between the current and next frame of {{FuncArg|clip}} &ndash; either the combined RGB difference or the Luma, U-chroma or V-chroma differences, respectively. In v2.61 an {{FuncArg|offset}} argument is added, which enables you to access the difference between the RGB, luma or chroma plane of the current frame and of ''any'' other frame. Note that for example clip.'''RGBDifferenceToNext'''(-1) = clip.'''RGBDifferenceToPrevious''', and clip.'''RGBDifferenceToNext'''(0) = 0.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 # both th1, th2 are positive thresholds; th1 is larger enough than th2
 scene_change = (YDifferenceFromPrevious > th1) && (YDifferenceToNext < th2)
 scene_change ? some_filter(...) : another_filter(...)
</div>

===== Color plane median, min, max, range =====
{{ScriptFunctionCode|YPlaneMedian||YPlaneMedian(clip [, int offset &#61; 0])}}
{{ScriptFunctionCode|UPlaneMedian||UPlaneMedian(clip [, int offset &#61; 0])}}
{{ScriptFunctionCode|VPlaneMedian||VPlaneMedian(clip [, int offset &#61; 0])}}
{{ScriptFunctionCode|BPlaneMedian||BPlaneMedian(clip [, int offset &#61; 0])}} {{AvsPluscon}}
{{ScriptFunctionCode|GPlaneMedian||GPlaneMedian(clip [, int offset &#61; 0])}} {{AvsPluscon}}
{{ScriptFunctionCode|RPlaneMedian||RPlaneMedian(clip [, int offset &#61; 0])}} {{AvsPluscon}}

{{ScriptFunctionCode|YPlaneMin||YPlaneMin(clip [, float threshold &#61; 0, int offset &#61; 0])}}
{{ScriptFunctionCode|UPlaneMin||UPlaneMin(clip [, float threshold &#61; 0, int offset &#61; 0])}}
{{ScriptFunctionCode|VPlaneMin||VPlaneMin(clip [, float threshold &#61; 0, int offset &#61; 0])}}
{{ScriptFunctionCode|BPlaneMin||BPlaneMin(clip [, float threshold &#61; 0, int offset &#61; 0])}} {{AvsPluscon}}
{{ScriptFunctionCode|GPlaneMin||GPlaneMin(clip [, float threshold &#61; 0, int offset &#61; 0])}} {{AvsPluscon}}{{ScriptFunctionCode|RPlaneMin||RPlaneMin(clip [, float threshold &#61; 0, int offset &#61; 0])}} {{AvsPluscon}}

{{ScriptFunctionCode|YPlaneMax||YPlaneMax(clip [, float threshold &#61; 0, int offset &#61; 0])}}
{{ScriptFunctionCode|UPlaneMax||UPlaneMax(clip [, float threshold &#61; 0, int offset &#61; 0])}}
{{ScriptFunctionCode|VPlaneMax||VPlaneMax(clip [, float threshold &#61; 0, int offset &#61; 0])}}
{{ScriptFunctionCode|BPlaneMax||BPlaneMax(clip [, float threshold &#61; 0, int offset &#61; 0])}} {{AvsPluscon}}
{{ScriptFunctionCode|GPlaneMax||GPlaneMax(clip [, float threshold &#61; 0, int offset &#61; 0])}} {{AvsPluscon}}{{ScriptFunctionCode|RPlaneMax||RPlaneMax(clip [, float threshold &#61; 0, int offset &#61; 0])}} {{AvsPluscon}}

{{ScriptFunctionCode|YPlaneMinMaxDifference||YPlaneMinMaxDifference(clip [, float threshold, int offset &#61; 0])}}
{{ScriptFunctionCode|UPlaneMinMaxDifference||UPlaneMinMaxDifference(clip [, float threshold, int offset &#61; 0])}}
{{ScriptFunctionCode|VPlaneMinMaxDifference||VPlaneMinMaxDifference(clip [, float threshold, int offset &#61; 0])}}
{{ScriptFunctionCode|BPlaneMinMaxDifference||BPlaneMinMaxDifference(clip [, float threshold, int offset &#61; 0])}} {{AvsPluscon}}
{{ScriptFunctionCode|GPlaneMinMaxDifference||GPlaneMinMaxDifference(clip [, float threshold, int offset &#61; 0])}} {{AvsPluscon}}
{{ScriptFunctionCode|RPlaneMinMaxDifference||RPlaneMinMaxDifference(clip [, float threshold, int offset &#61; 0])}} {{AvsPluscon}}

: This group of functions return statistics about the distribution of pixel values on a plane (Luma, U-chroma and V-chroma, respectively). The statistics are, in order of presentation: maximum, minimum, median and range (maximum - minimum difference). 
: {{FuncArg|threshold}} is a percentage, stating how many percent of the pixels are allowed above or below minimum. The threshold is optional and defaults to 0. In v2.61 an {{FuncArg|offset}} argument is added, which enables you to access the statistics of other frames than the current one.

''Examples:''
<div {{BoxWidthIndent|56|2}} >
 # median and average are close only on even distributions; 
 # this can be a useful diagnostic
 have_intense_brights = YPlaneMedian() - AverageLuma() < threshold
 ...
 # a simple per-frame normalizer to [16..235], CCIR, range
 [[Levels]](YPlaneMin(), 1.0, YPlaneMax(), 16, 235)
</div>
</div>

== Runtime functions for frame properties ==
<div style="max-width:62em" >
: Core and concept ported from VapourSynth
: Frame properties are per-frame data which can only be read and written within runtime functions. e.g. Source or other filters can feed useful data into frame properties such as information on colorimetry.
: Imagine them as an array of zero or more elements of PropertyName=Value
<br>
: Frame property getter and setter functions are evaluated at every frame. They can be used inside the scripts passed to runtime filters ([[ScriptClip]]). They are allowed in [[FrameEvaluate]] but since it does not return an altered frame, writing a frame property there has zero effect.
:* frame properties are key-value(s) pairs
:** Key is an alphanumeric identifier.
:** Values can be of single value or array of type
:*** 64 bit integers (32 bit integer when converted to AVSValue inside Avisynth+, AVSValue limitation)
:*** 64 bit doubles (32 bit float when converted to AVSValue inside Avisynth+, AVSValue limitation)
:*** strings (or data) with given length. strings are null terminated
:*** frame references (PVideoFrame)
:*** clip references (PClip)
:* property setting has 3 modes: 0-replace 1-append 2-touch (see AVSPropAppendMode in avisynth.h)::
:** 0 - single value for that key is replaced
:** 1 - property is appended (make arrays by calling with mode=1 consecutively)
:** 2 - touch

===== Property set =====

===== Property get =====

==== Deleting properties ====
<div style="max-width:62em" >
: Delete one specific property or all property entries

{{ScriptFunctionH5|propDelete|{{AvsPluscon}}|propDelete(clip, string)}}
: Deletes a property by name. If property does not exist, do nothing.
:* {{FuncArg|clip}} (required) specifies clip.
:* {{FuncArg|string}} (required) key_name (case sensitive) specifies the name of the parameter to delete
''Example:''
<div {{BoxWidthIndent|56|2}} >
  ScriptClip("""propDelete("my_spec_prop")""")
</div>

{{ScriptFunctionH5|propClearAll|{{AvsPluscon}}|propClearAll(clip)}}
: Clears all properties for a given video frame
:* {{FuncArg|clip}} (required) specifies clip.

==== Other property functions ====
{{ScriptFunctionH5|propShow|{{AvsPluscon}}|propShow(clip, integer "size", bool "showtype")}}
: The filter is not a runtime function but is shown here. This debug filter lists all frame properties on screen.
: Listing appears as a name = value list. Arrays values are put between [ and ]
: Top line contains the number of properties. If no properties found, nothing is displayed.
:* {{FuncArg|clip}} (required) specifies clip.
:* {{FuncArg|integer}} "size" default(16), font size to use (the "Text" filter is used for display, sizes are of limited set)
:* {{FuncArg|bool}} "showtype" default(false), if true, the data type in parenthesis appears next to the property key name

== Script functions ==
<div style="max-width:62em" >
: These provide AviSynth script information.

{{ScriptFunctionH5|ScriptName|v2.60|ScriptName()}}
: Returns the path and filename of the loaded script as a string.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 name = ScriptName() # name = "F:\ProjectXYZ\video.avs"
</div>

{{ScriptFunctionH5|ScriptNameUtf8|{{AvsPluscon}}|ScriptNameUtf8()}}
: Returns the path and filename of the loaded script as a [[wikipedia:Unicode|Unicode]] string, encoded in [[wikipedia:UTF-8|UTF8]].

{{ScriptFunctionH5|ScriptFile|v2.60|ScriptFile()}}
: Returns the filename of the loaded script as a string.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 file = ScriptFile() # file = "video.avs"
</div>

{{ScriptFunctionH5|ScriptFileUtf8|{{AvsPluscon}}|ScriptFileUtf8()}}
: Returns the filename of the loaded script as a [[wikipedia:Unicode|Unicode]] string, encoded in [[wikipedia:UTF-8|UTF8]].

{{ScriptFunctionH5|ScriptDir|v2.60|ScriptDir()}}
: Returns the path of the loaded script as a string.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 folder = ScriptDir() # folder = "F:\ProjectXYZ"
</div>

{{ScriptFunctionH5|ScriptDirUtf8|{{AvsPluscon}}|ScriptDirUtf8()}}
: Returns the path of the loaded script as a [[wikipedia:Unicode|Unicode]] string, encoded in [[wikipedia:UTF-8|UTF8]].

{{ScriptFunctionH5|SetLogParams|{{AvsPluscon}}|SetLogParams([string ''target'', int ''level''])}}
: Sets a file path for a log file, used by [[#LogMsg|LogMsg]] and internal error reporting.
:* {{FuncArg|target}} names a file which will be created when the script loads. If attempting to create or write to {{FuncArg|target}} fails, the script will raise an error immediately. If the file exists, new log entries will be appended to the end. If omitted, {{FuncArg|target}} defaults to [[wikipedia:Stderr|stderr]].
:* {{FuncArg|level}} sets the log ''verbosity''; it can be one of the following:
::{| border="0"
|-
|style="line-height:1.0em"|{{BoldColor|#669999|85|■}} <tt>LOG_ERROR</tt>
|style="line-height:1.0em"|<small>(1)</small>
|style="line-height:1.0em"|creates the fewest log entries
|-
|style="line-height:1.0em"|{{BoldColor|#669999|85|■}} <tt>LOG_WARNING</tt>&nbsp;
|style="line-height:1.0em"|<small>(2)</small>&nbsp;
|style="line-height:1.0em"|
|-
|style="line-height:1.0em"|{{BoldColor|#669999|85|■}} <tt>LOG_INFO</tt>
|style="line-height:1.0em"|<small>(3)</small>
|style="line-height:1.0em"|creates the most log entries
|}
::If omitted, {{FuncArg|level}} defaults to <tt>LOG_INFO</tt>.  
:''Examples'' see [[#LogMsg|LogMsg]] below.

{{ScriptFunctionH5|LogMsg|{{AvsPluscon}}|LogMsg(string, int)}}
: Creates a new log entry.
:* {{FuncArg|string}} (required) specifies the log message.
:* {{FuncArg|int}} (required) specifies the log entry level: see [[#SetLogParams|SetLogParams]] above.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 ## creating file and set path for future log entries:
 SetLogParams("<path>\_test1.log", LOG_INFO)
 
 ...''log contents:''
 (empty)
</div>

<div {{BoxWidthIndent|56|2}} >
 ## logging an INFO message:
 SetLogParams("<path>\_test2.log", LOG_INFO)
 LogMsg("this is a test", LOG_INFO)
 
 ''log contents:''
 ---------------------------------------------------------------------
 INFO: this is a test
</div>

<div {{BoxWidthIndent|56|2}} >
 ## logging a script error:
 SetLogParams("<path>\_test3.log", LOG_INFO)
 foo("bar") ## ERROR!
 
 ...''log contents (redundant entries are common):''
 ERROR: Script error: There is no function named 'foo'.
 ---------------------------------------------------------------------
 ERROR: Script error: There is no function named 'foo'.
 (<path>\_test.avs, line 35)
</div>

<div {{BoxWidthIndent|56|2}} >
 ## logging INFO context for script error:
 SetLogParams("<path>\_test4.log", LOG_INFO)
 function MyFunction(clip C)
 {
     C
     [[Control_structures|try]] {
         foo("bar") ## ERROR!
     } catch (err_msg) {
         msg2 = "Error in MyFunction: "
         LogMsg([[#Time|Time]]("%Y-%m-%d %I:%M:%S %p, %z") + ": " + msg2, LOG_INFO)
         #[[#Assert|Assert]](false, msg2 + err_msg) ## optional: stop script, else continue
     }
     return Last
 }
 
 ''log contents (redundant entries omitted):''
 ---------------------------------------------------------------------
 ERROR: Script error: There is no function named 'foo'.
 (<path>\_test.avs, line 54)
 ---------------------------------------------------------------------
 INFO: 2017-11-12 11:03:41 AM, -0500: Error in MyFunction:
 (<path>\_test.avs, line 54)
</div>

{{ScriptFunctionH5|GetProcessInfo|{{AvsPluscon}}|GetProcessInfo(int)}}
: Returns information about the [[wikipedia:Process_(computing)|process]] the script is running in.
: The ''int'' argument has two legal values:
:* if ''0'' (default), returns ''64'' for a 64-bit process or ''32'' for a 32-bit process.
:* else if ''1'',
:** returns 0 for 32-bit process on 32-bit OS;
:** returns 1 for 32-bit process on 64-bit OS;
:** returns 2 for 64-bit process on 64-bit OS;
:** else returns -1 (unknown)
:: /// [[TODO]] this is preliminary info

== String functions ==
<div style="max-width:62em" >
: These provide common operations on string variables.

{{ScriptFunctionH5|LCase||LCase(string)}}
: Returns lower case of {{FuncArg|string}}.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 LCase("AviSynth") = "avisynth"
</div>

{{ScriptFunctionH5|UCase||UCase(string)}}
: Returns upper case of {{FuncArg|string}}.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 UCase("AviSynth") = "AVISYNTH"
</div>

{{ScriptFunctionH5|StrToUtf8||StrToUtf8(string)}} {{AvsPluscon}}
: Converts {{FuncArg|string}} from ANSI to [[wikipedia:UTF-8|UTF8]].

{{ScriptFunctionH5|StrFromUtf8||StrFromUtf8(string)}} {{AvsPluscon}}
: Converts {{FuncArg|string}} from [[wikipedia:UTF-8|UTF8]] to ANSI.

{{ScriptFunctionH5|StrLen||StrLen(string)}}
: Returns length of {{FuncArg|string}}.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 StrLen("AviSynth") = 8
</div>

{{ScriptFunctionH5|RevStr||RevStr(string)}}
: Returns {{FuncArg|string}} backwards.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 RevStr("AviSynth") = "htnySivA"
</div>

{{ScriptFunctionH5|LeftStr||LeftStr(string, int)}}
: Returns first {{FuncArg|int}} count of characters.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 LeftStr("AviSynth", 3) = "Avi"
</div>

{{ScriptFunctionH5|RightStr||RightStr(string, int)}}
: Returns last {{FuncArg|int}} count of characters.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 RightStr("AviSynth", 5) = "Synth"
</div>

{{ScriptFunctionH5|MidStr||MidStr(string, int pos [, int length])}}
: Returns substring starting at {{FuncArg|pos}} for optional {{FuncArg|length}} or to end. {{FuncArg|pos}}=1 specifies start.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 MidStr("AviSynth", 3, 2) = "iS"
</div>

{{ScriptFunctionH5|FindStr||FindStr(string, substring)}}
: Returns (1-based) position of {{FuncArg|substring}} within {{FuncArg|string}} 
:* Note this function is case-sensitive. 
:* Returns 0 if {{FuncArg|substring}} is not found.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Findstr("AviSynth", "Syn") ## returns 4
 Findstr("AviSynth", "SYN") ## returns 0
</div>

{{ScriptFunctionH5|ReplaceStr|{{AvsPluscon}}|ReplaceStr(string, substring, replacement_string [, bool sig])}}
: Replaces occurrences of {{FuncArg|substring}} with {{FuncArg|replacement_string}} and returns the result. 
:* {{FuncArg|sig}} if false (the default), search is case-sensitive; if true, search is not case-sensitive.
:* Avisynth 2.6.x users have other options, such as the [[User_defined_script_functions|user]] function below, adapted from ''StrReplace'', found [[HDColorBars|here]].
<div {{BoxWidthIndent|46|4}} >
 function ReplaceStr(string base, string sought, string repstr) {
     pos = FindStr(base, sought)
     return (sought=="" || pos==0) ? base : ReplaceStr(
     \       LeftStr(base, pos-1) + repstr +
     \       MidStr(base, pos+StrLen(sought)),
     \       sought, repstr)
 }
</div>
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 ReplaceStr("FlipHorizontal", "Horizontal", "Vertical")
 ReplaceStr("''$a'' x *", "''$a''", String(1.5)) ## (a [[MaskTools2|MaskTools]] expression with argument)
</div>

{{ScriptFunctionH5|Format|{{AvsPluscon}}|Format(formatstring [, value1, value2, ...])}}
: Mixes the string containing inline placeholders with parameters each converted to strings and returns the result. 
:* {{FuncArg|formatstring}} unnamed parameter, string literal with parameter insertion points marked with {}.
:* {{FuncArg|value1}}, {{FuncArg|value2}},etc. zero or more values which are inserted into the format string one after another
:Description:
::The format string consists of
::
:::*ordinary characters (except { and }), which are copied unchanged to the output,
:::*escape sequences double "{" ("{{") and double "}" ("}}"), which are replaced with "{" and "}" respectively in the output, and
:::*replacement fields.
::: 
:::Each replacement field has the following format:
::::introductory { character;
::::(optional)
::::arg-id, a non-negative number;
:::::or:
::::identifier which is used for lookup named parameters. (["name", value] construction)
:::::or:
::::valid AviSynth variable name
::::final } character.
:::
:::If arg-id is a number it specifies the index of the argument in args whose value is to be used for formatting;
:::Index is zero based.
:::
:::If arg-id is string then it serves as a lookup key from the parameters list given as an array ["name",value] pair.
:::If not found, then arg-id is searched among Avisynth variables.
:::
:::If arg-id is omitted, the arguments are used in order.
:::Mixing manual and automatic indexing is not an error.
:::
::Notes
:::It is not an error to provide more arguments than the format string requires:
<div {{BoxWidthIndent|56|2}} >
 Format("{} {}!", "Hello", "world", "something") # OK, produces "Hello world!"
</div>

''Example: By Avisynth variable''
<div {{BoxWidthIndent|56|2}} >
 max_pixel_value = 255
 SubTitle(Format("max={max_pixel_value}!")) # no format value given, inserts directly from variable
</div>
''Example: By index:''
<div {{BoxWidthIndent|56|2}} >
 SubTitle(Format("{0} {1} {0}", "Home", "sweet"))
</div>
''Example: by order:''
<div {{BoxWidthIndent|56|2}} >
 SubTitle(Format("{} {} {}", "AviSynth", "+", 2020))
</div>
''Example: by Array name-value pairs:''
<div {{BoxWidthIndent|56|2}} >
 SubTitle(Format("maximum={max} minimum={min} max again {max}!", ["max",255], ["min",0]))
</div>
:*since Avisynth+ 3.6

{{ScriptFunctionH5|FillStr|v2.60|FillStr(int [, string])}}
: Fills a string. When {{FuncArg|int}}>1 it concatenates the {{FuncArg|string}} {{FuncArg|int}} times. {{FuncArg|string}} is "<tt> </tt>" (space) by default.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 FillStr(1, "AviSynth") = "AviSynth"
 FillStr(2, "AviSynth") = "AviSynthAviSynth"
</div>

{{ScriptFunctionH5|StrCmp|v2.60|StrCmp(string, string)}}
: Compares two character strings. The comparison is case-sensitive. If the first string is less than the second string, the return value is negative. If it's greater, the return value is positive. If they are equal, the return value is zero. (The actual value seems to be language dependent so it can't be relied upon.)
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 StrCmp("AviSynth", "AviSynth") = 0 # strings are equal.
 StrCmp("AviSynth", "Avisynth") != 0 # strings are not equal.
</div>

{{ScriptFunctionH5|StrCmpi|v2.60|StrCmpi(string, string)}}
: Compares two character strings. The comparison is not case-sensitive. If the first string is less than the second string, the return value is negative. If it's greater, the return value is positive. If they are equal, the return value is zero. (The actual value seems to be language dependent so it can't be relied upon.)
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 StrCmpi("AviSynth", "AviSynth") = 0 # strings are equal.
 StrCmpi("AviSynth", "Avisynth") = 0 # strings are equal.
 StrCmpi("abcz", "abcdefg") != 0 
 # returns the difference betweeen "z" and "d" (which is positive).
</div>

===== TrimLeft, TrimRight, TrimAll =====
{{ScriptFunctionCode|TrimLeft||TrimLeft(string)}}
{{ScriptFunctionCode|TrimRight||TrimRight(string)}}
{{ScriptFunctionCode|TrimAll||TrimAll(string)}}
: {{AvsPluscon}} Removes whitespace characters (space, tab, [[wikipedia:Non-breaking_space|nonbreaking space]]) from the ''left, right,'' or ''both'' ends of a string.

{{ScriptFunctionH5|Chr||Chr(int)}}
: Returns the ASCII character. 
: Note that characters above the ASCII character set (ie above 127) are code page dependent and may render different (visual) results in different systems. This has an importance only for user-supplied localised text messages.
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Chr(34) returns the quote character
 Chr(9)  returns the tab   character
</div>

{{ScriptFunctionH5|Ord|v2.60|Ord(string)}}
: Gives the ordinal number (character code) of the first character of {{FuncArg|string}} (works like php [http://php.net/manual/en/function.ord.php ord] or Basic [http://msdn.microsoft.com/en-us/library/xfw01fx4%28v=vs.84%29.aspx Asc])
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 Ord("a") = 97
 Ord("AviSynth") = Ord("A") = 65
 Ord("§") = 167
</div>

{{ScriptFunctionH5|Time||Time(string)}}
: Returns a string with the current system time formatted as defined by {{FuncArg|string}}.

: The string may contain any of the codes for output formatting presented below:
:{| class="wikitable"
 |-
 ! style="width:9em" | Code
 ! style="width:38em" | Description
 |-
 |%a
%A  
 | Abbreviated weekday name
Full weekday name
 |-
 |%b
%B  
 | Abbreviated month name
Full month name
 |-
 |%c  
 | Date and time representation appropriate for locale
 |-
 |%d  
 | Day of month as decimal number (01 - 31)
 |-
 |%H
%I  
 | Hour in 24-hour format (00 - 23)
Hour in 12-hour format (01 - 12)
 |-
 |%j  
 | Day of year as decimal number (001 - 366)
 |-
 |%m  
 | Month as decimal number (01 - 12)
 |-
 |%M  
 | Minute as decimal number (00 - 59)
 |-
 |%p  
 | Current locale's A.M./P.M. indicator for 12-hour clock
 |-
 |%S  
 | Second as decimal number (00 - 59)
 |-
 |%U  
 | Week of year as decimal number, with Sunday as first day of week (00 - 53)
 |-
 |%w  
 | Weekday as decimal number (0 - 6; Sunday is 0)
 |-
 |%W  
 | Week of year as decimal number, with Monday as first day of week (00 - 53)
 |-
 |%x  
 | Date representation for current locale
 |-
 |%X  
 | Time representation for current locale
 |-
 |%y
%Y  
 | Year without century, as decimal number (00 - 99)
Year ''with'' century, as decimal number
 |-
 |%z, %Z  
 | Time-zone name or abbreviation; no characters if time zone is unknown
 |-
 |%%  
 | Percent sign 
 |}

: The '#' flag may prefix any formatting code. In that case, the meaning of the format code is changed as follows:
:{| class="wikitable"
 |-
 ! style="width:9em" |Code with '#' flag
 ! style="width:38em" |Change in meaning
 |-
 |%#'''a''', %#'''A''', %#'''b''', 
%#'''B''', %#'''p''', %#'''X''', 
%#'''z''', %#'''Z''', %#'''%'''
 | No change; flag is ignored. 
 |-
 |%#'''c''' 
 | Long date and time representation, appropriate for current locale. 
For example, ''"Tuesday, March 14, 1995, 12:41:29"'' 
 |-
 |%#'''x''' 
 | Long date representation, appropriate to current locale. 
For example, ''"Tuesday, March 14, 1995"''
 |-
 |%#'''d''', %#'''H''', %#'''I''', 
%#'''j''', %#'''m''', %#'''M''', 
%#'''S''', %#'''U''', %#'''w''', 
%#'''W''', %#'''y''', %#'''Y''' 
 | Remove leading zeroes (if any).
 |}
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 v = Time("%Y-%m-%d")        # "2010-03-01"
 v = Time("%d-%b-%Y")        # "01-Mar-2010"
 v = Time("%#d/%#m/%y")      # "1/3/10"
 v = Time("%I:%M:%S %p, %z") # "08:04:42 PM, GMT Standard Time"
 v = Time("%H:%M:%S %z")     # "20:04:42 GMT Standard Time"
</div>

== Version functions ==
<div style="max-width:62em" >
: These provide AviSynth version information.

{{ScriptFunctionH5|VersionNumber||VersionNumber()}}
: Returns AviSynth version number as a float.
:* Note: use [[#VersionString|VersionString]] below to determine if running in [[AviSynth+]].
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 VersionNumber ## returns 2.60 (release version as of 11/2017)
 VersionNumber ## returns 2.61 (beta)
 VersionNumber ## returns 2.60 (AVS+ release 2508)
</div>

{{ScriptFunctionH5|VersionString||VersionString()}}
: Returns AviSynth version info as a string (first line used in [[Version]]() command).
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 VersionString ## returns "AviSynth 2.60, build:Mar 31 2015 [16:38:54]"
 VersionString ## returns "AviSynth 2.61, build:May 17 2016 [16:06:18] VC2008Exp"
 VersionString ## returns "AviSynth+ 0.1, (r2508, MT, x86_64)"
</div>

<div {{BoxWidthIndent|56|2}} >
 function IsAvsPlus()
 {
     sVer = [[#LCase|LCase]](VersionString) 
     return ([[#FindStr|FindStr]](sVer, "avisynth+")    > 0)
     \   || (FindStr(sVer, "avisynthplus") > 0)
 }
</div>

{{ScriptFunctionH5|IsVersionOrGreater||bool IsVersionOrGreater(int majorVersion, int minorVersion [,int bugfixVersion]) {{AvsPluscon}}}}
: Returns true if Avisynth+ version is is equal or greater than the required one in the parameters.
: Since Avisynth+ 3.5
''Examples:''
<div {{BoxWidthIndent|56|2}} >
 isAtLeast3_10 = IsVersionOrGreater(3,10)
 isAtLeast3_5_1 = IsVersionOrGreater(3,5,1)
</div>

</div>

== Other helper functions ==
<div style="max-width:62em" >
: Non-categorized functions

{{ScriptFunctionH5|BuildPixelType||string BuildPixelType(string family, int bits, int chroma, bool compat, bool oldnames, clip sample_clip)}} {{AvsPluscon}}
: Creates a video format (pixel_type) string by giving a colorspace family, bit depth, optional chroma subsampling and/or a 
: template clip, from which the undefined format elements are inherited.
: 
:* string {{FuncArg|family}}
:: defines color family: "Y", "YUV", "YUVA", "RGB", "RGBA"
:: use "RGB" for both planar RGB and classic packed RGB24 and RGB48 - {{FuncArg|compat}} switches to classic formats 
:* int {{FuncArg|bits}}
:: intended bit depth: 8, 10, 12, 14, 16, 32. In Avisynth+ 8-16 bits are integer formats, 32 bit is float
:* int {{FuncArg|chroma}}
:: chroma subsampling: 411, 420, 422, 444. Applies for YUV(A) formats. Ignored for RGB(A) and Y
:* bool {{FuncArg|compat}} default false
:: When set to true, function returns packed RGB(A) formats instead of planar RGB(A) (e.g. "RGB48" instead of "RGBP16"), when applicable
:* bool {{FuncArg|oldnames}} default false
:: when true, function returns "YV12", "YV16", "YV24" instead of "YUV420P8", "YUV422P8" and "YUV444P8" respectively
:* clip {{FuncArg|sample_clip}} when given, the clip serves as the base format, all optional parameters (bits, subsampling) will modify only its respective properties

:* see also: use [[#Other_helper_functions|ColorSpaceNameToPixelType]] to convert a colorspace string to an integer pixel_type
''Examples:'' 

:: define "YUV444P10"
<div {{BoxWidthIndent|56|2}} >
 family = "YUV"
 bits = 10
 chroma = 444
 compat = false
 oldformat = false
 s = BuildPixelType(family, bits, chroma, compat, oldformat)
 BlankClip(width=320,height=200,length=len,pixel_type=s,color=$008080).Info()
</div>

:: Change only bit depth to 16, sample format is of an existing clip
<div {{BoxWidthIndent|56|2}} >
 newbits = 16
 c = last
 s = BuildPixelType(bits=newbits, sample_clip=c)
 BlankClip(width=320,height=200,length=len,pixel_type=s,color=$008080).Info()
</div>

{{ScriptFunctionH5|ColorSpaceNameToPixelType||int ColorSpaceNameToPixelType(string)}} {{AvsPluscon}}
: Creates a video format (pixel_type) by providing a colorspace name
: 
:* some formats have multiple valid names: "YV12" is identical to "YUV420P8", "YV16" = "YUV422P8", "YV24" = "YUV444P8"

</div>

----
Back to [[AviSynth Syntax]].
</div>

[[Category:Internal_functions]]
[[Category:AviSynth_Syntax]]
[[Category:Scripting_Basics]]
@@ Line 18: / Line 18: @@
 # [[#Bit_functions|Bit functions]]
 # [[#Runtime_functions|Runtime functions]]
-# [[#Functions_for_frame_properties|Functions for frame properties]]
+# [[#Runtime_functions_for_frame_properties|Runtime functions for frame properties]]
 # [[#Script_functions|Script functions]]
 # [[#String_functions|String functions]]
@@ Line 394: / Line 394: @@
 : Sets the maximum memory that AviSynth uses (in MB) to the value of {{FuncArg|amount}}. Setting to zero just returns the current Memory Max value. In the 2.5 series the default Memory Max value is 25% of the free physical memory, with a minimum of 16MB.
 : The default Memory Max is also limited to 512MB.
-: {{AvsPluscon}}In Avisynth+ this limit for default Memory Max is 1024MB for 32 bits and 4096MB on the x64 version
+: In Avisynth+ this limit for default Memory Max is 1024MB for 32 bits and 4096MB on the x64 version
 : DefaultMemoryMax = minimum(physical_memory / 4, secondary_memory_max_limit)
 : for classic Avisynth see the table below
@@ Line 423: / Line 423: @@
   SetMemoryMax(128)
 </div>
-:{{AvsPluscon}}{{FuncDef|SetMemoryMax(int, int “type”, int “index”)}}
-:With additional arguments for devices such as GPUs. Memory usage is managed individually for devices such as GPUs.
-<br>
-::{{Par2||int|}}
-:::Device (including CPU) memory limit (MB)
-::{{Par2|type|int|}}
-:::Device type. The following values are available:
-::::DEV_TYPE_CPU: CPU (default)
-::::DEV_TYPE_CUDA: GPU
-::{{Par2|index|int|}}
-:::Device number. Same as onCUDA device_index. Only 0 for DEV_TYPE_CPU.
-:::Default value: 0
 <div style="max-width:62em" >
@@ Line 1,261: / Line 1,246: @@
 </div>
-== Functions for frame properties ==
+== Runtime functions for frame properties ==
 <div style="max-width:62em" >
-: Core and concept ported from VapourSynth.
+: Core and concept ported from VapourSynth
-: Frame properties are per-frame data. Source or other filters can store useful data into frame properties such as information on colorimetry.
+: Frame properties are per-frame data which can only be read and written within runtime functions. e.g. Source or other filters can feed useful data into frame properties such as information on colorimetry.
 : Imagine them as an array of zero or more elements of PropertyName=Value
-: Reading them is possible only by runtime functions.
+<br>
-: <br>
+: Frame property getter and setter functions are evaluated at every frame. They can be used inside the scripts passed to runtime filters ([[ScriptClip]]). They are allowed in [[FrameEvaluate]] but since it does not return an altered frame, writing a frame property there has zero effect.
-: Note:
+:* frame properties are key-value(s) pairs
-: At the moment (v3.6.2test7) Avisynth+ provides only the necessary framework for handling (set, read, clear, pass) such properties. None of its internal functions (such as color space converters) set or work upon frame property values.
-: There are already filters (like avsresize) and source plugins that are already using frame properties. Avisynth+ core will rely on frame in the future as well.
-: <br>
-: Developer info:
-: On filter level the set of frame properties should be copied from a previous (or specific) input frame. When filter is using env->MakeWritable in its GetFrame method this happens automatically.
-: But a simple env->NewVideoFrame means a dead-end for frame property passing mechanism. So filter must either use env->NewVideoFrameP which has an additional parameter: a source frame of the frame properties.
-: Or frame properties have to be copied later, programatically by the copyFrameProps ScriptEnvironment function.
-: For compatibility reasons NewVideoFrameP should be called adaptively instead of the traditional NewVideoFrame: usable after detecting Avisynth interface version 8 (NewVideoFrameP was introduced in v8).
-: What happens if this copy is not done properly? Then the filter is a dead-end for frame properties since NewVideoFrame constructs new frame with no frame properties. All old filters will behave like this.<br>
-: <br>
-: Frame property getter functions are evaluated at every frame. They can be used inside the scripts passed to runtime filters ([[ScriptClip]]).<br>
-: Frame property setters can be called both at script level and in runtime. When a property is set on script level it will be constant along the lifetime of the whole clip, unless it is changed in runtime, inside ScriptClip.
-: Though using property setter functions are allowed in [[FrameEvaluate]] but since it does not return an altered frame, writing a frame property there has zero effect.<br>
-: <br>
-:* frame properties are stored as key-value pairs
 :** Key is an alphanumeric identifier.
 :** Values can be of single value or array of type
-:*** 64 bit integer (32 bit integer when converted to AVSValue inside Avisynth+, AVSValue limitation)
+:*** 64 bit integers (32 bit integer when converted to AVSValue inside Avisynth+, AVSValue limitation)
-:*** 64 bit double (32 bit float when converted to AVSValue inside Avisynth+, AVSValue limitation)
+:*** 64 bit doubles (32 bit float when converted to AVSValue inside Avisynth+, AVSValue limitation)
-:*** string (or byte data) with given length. Strings are null terminated.
+:*** strings (or data) with given length. strings are null terminated
-:*** frame reference (PVideoFrame)
+:*** frame references (PVideoFrame)
-:*** clip reference (PClip)
+:*** clip references (PClip)
 :* property setting has 3 modes: 0-replace 1-append 2-touch (see AVSPropAppendMode in avisynth.h)::
 :** 0 - single value for that key is replaced
@@ Line 1,296: / Line 1,266: @@
 :** 2 - touch
-==== Reserved frame property names ====
+===== Property set =====
-: There are quasi-standard frame property names which are used widespread.
-: As frame properties came from VapourSynth (see "Reserved Frame Properties" at http://www.vapoursynth.com/doc/apireference.html), it is convenient that Avisynth plugins use the same properties and values.
-: Keys starting with _ have strictly defined meanings specified below. It is acceptable to not set any of these keys if they are unknown. It is also a fatal error to set them to a value not specified below.
-{{ScriptFunctionH5|_ChromaLocation||int _ChromaLocation}}
-: Chroma sample position in YUV formats.
-:: 0=left, 1=center, 2=topleft, 3=top, 4=bottomleft, 5=bottom.
-{{ScriptFunctionH5|_ColorRange||int _ColorRange}}
+===== Property get =====
-: Full or limited range (PC/TV range). Primarily used with YUV formats.
-:: 0=full range, 1=limited range.
-{{ScriptFunctionH5|_Primaries||int _Primaries}}
-: Color primaries as specified in ITU-T H.265 Table E.3.
-{{ScriptFunctionH5|_Matrix||int _Matrix}}
-: Matrix coefficients as specified in ITU-T H.265 Table E.5.
-{{ScriptFunctionH5|_Transfer||int _Transfer}}
-: Transfer characteristics as specified in ITU-T H.265 Table E.4.
-{{ScriptFunctionH5|_FieldBased||int _FieldBased}}
-: If the frame is composed of two independent fields (interlaced).
-:: 0=frame based (progressive), 1=bottom field first, 2=top field first
-{{ScriptFunctionH5|_AbsoluteTime||float _AbsoluteTime}}
-: The frame’s absolute timestamp in seconds if reported by the source filter. Should only be set by the source filter and not be modified. Use durations for all operations that depend on frame length.
-{{ScriptFunctionH5|_DurationNum||int _DurationNum}}
-{{ScriptFunctionH5|_DurationDen||int _DurationDen}}
-: The frame’s duration in seconds as a rational number. Filters that modify the framerate should also change these values.
-: This fraction should always be normalized.
-{{ScriptFunctionH5|_Combed||int _Combed (boolean)}}
-: Whether or not the frame needs postprocessing, usually hinted from field matching filters.
-{{ScriptFunctionH5|_Field||int _Field}}
-: If the frame was produced by something like core.std.SeparateFields, this property signals which field was used to generate this frame.
-:: 0=from bottom field, 1=from top field.
-{{ScriptFunctionH5|_PictType||string _PictType}}
-: A single character describing the frame type. It uses the common IPB letters but other letters may also be used for formats with additional frame types.
-{{ScriptFunctionH5|_SARNum||int _SARNum}}
-{{ScriptFunctionH5|_SARDen||int _SARDen}}
-: Pixel (sample) aspect ratio as a rational number.
-{{ScriptFunctionH5|_SceneChangeNext||int _SceneChangeNext (boolean)}}
-: If 1, this frame is the last frame of the current scene. The next frame starts a new scene.
-{{ScriptFunctionH5|_SceneChangePrev||int _SceneChangePrev (boolean)}}
-: If 1, this frame starts a new scene.
-==== Property set ====
-: Input value of setter functions are to be come either
-:*from the return value of "function objects"
-:*direct value
-: Property setter function names begin with propSet
-: Common parameters:
-::*clip c,
-::*string key_name,
-::*direct value of supported types (integer, float, string, array, clip) or a "function object"
-::*int "mode": 0=replace (default), 1=append, 2=touch. There is no append mode for inserting a full array into the property.
-{{ScriptFunctionH5|propSet|{{AvsPluscon}}|propSet(clip, string key_name, function func_obj [, integer "mode"])}}
-: generic property setter, automatic type recognition by the return value of the function object
-{{ScriptFunctionH5|propSet|{{AvsPluscon}}|propSet(clip, string key_name, integer value [, integer "mode"])}}
-{{ScriptFunctionH5|propSet|{{AvsPluscon}}|propSet(clip, string key_name, float value [, integer "mode"])}}
-{{ScriptFunctionH5|propSet|{{AvsPluscon}}|propSet(clip, string key_name, string value [, integer "mode"])}}
-{{ScriptFunctionH5|propSet|{{AvsPluscon}}|propSet(clip, string key_name, array value)}}
-{{ScriptFunctionH5|propSet|{{AvsPluscon}}|propSet(clip, string key_name, clip value [, integer "mode"])}}
-: The above four functions are setting a property by a directly passed values
-: note: array must contain only the similarly typed values, e.g. cannot mix strings with integers.
-{{ScriptFunctionH5|propSetInt|{{AvsPluscon}}|propSetInt(clip, string key_name, function func_obj [, integer "mode"])}}
-{{ScriptFunctionH5|propSetFloat|{{AvsPluscon}}|propSetFloat(clip, string key_name, function func_obj [, integer "mode"])}}
-{{ScriptFunctionH5|propSetString|{{AvsPluscon}}|propSetString(clip, string key_name, function func_obj [, integer "mode"])}}
-{{ScriptFunctionH5|propSetArray|{{AvsPluscon}}|propSetArray(clip, string key_name, function func_obj [, integer "mode"])}}
-{{ScriptFunctionH5|propSetClip|{{AvsPluscon}}|propSetClip(clip, string key_name, function func_obj [, integer "mode"])}}
-: these setters accept only the specific type
-==== Property get ====
-: Get properties by name or as a whole
-: Common parameters:
-:: clip c,
-:: string key_name,
-:: integer "index", (default 0): for zero based indexing array access
-:: integer "offset" (default 0), similar to the other runtime functions: frame offset (e.g. -1: previous, 2: next next)
-{{ScriptFunctionH5|propGetAny|{{AvsPluscon}}|propGetAny(clip, string key_name[, integer "index", integer "offset"])}}
-: returns the automatically detected type
-{{ScriptFunctionH5|propGetInt|{{AvsPluscon}}|propGetInt(clip, string key_name[, integer "index", integer "offset"])}}
-: returns only if value is integer, throws an error otherwise (note: unlike Avisynth integer frame properties internally use 64 bit integers)
-{{ScriptFunctionH5|propGetFloat|{{AvsPluscon}}|propGetFloat(clip, string key_name[, integer "index", integer "offset"])}}
-: returns only if value is float, throws an error otherwise (note: unlike Avisynth float frame properties internally use 64 bit doubles)
-{{ScriptFunctionH5|propGetString|{{AvsPluscon}}|propGetString(clip, string key_name[, integer "index", integer "offset"])}}
-: returns only if value is string, throws an error otherwise
-{{ScriptFunctionH5|propGetAsArray|{{AvsPluscon}}|propGetAsArray(clip, string key_name[, integer "index", integer "offset"])}}
-: A frame property can hold multiple values of the same type: it can be an array
-: propGetAsArray returns an array. For a single property array size will be 1. (only in array-aware AviSynth+ versions)
-{{ScriptFunctionH5|propGetClip|{{AvsPluscon}}|propGetClip(clip, string key_name[, integer "index", integer "offset"])}}
-: returns only if value is clip, throws an error otherwise (since 3.7.1)
-{{ScriptFunctionH5|propGetAll|{{AvsPluscon}}|propGetAll(clip [, integer "offset"])}}
-: Returns all frame properties in an array of [key-value] pairs. Array size will be 'numProps'
-: Each key-value pair is contained in a two dimensional subarray.
-: If the property value for a given key is an array again then "value" will be an array as well.
-: Once you have the array with all properties you can access them with the "associative" feature of AviSynth array access
-''Example:''
-<div {{BoxWidthIndent|56|2}} >
-  ScriptClip("""last.propSet("cica","hello"+String(current_frame)).\
-    propSetInt("test_i1",function[](clip c) { return current_frame*3 }).\
-    propSet("test_i2", current_frame * 2) """)
-  ScriptClip("""p = propGetAll() \
-    SubTitle("size:" + String(p.ArraySize()) + " " + \
-                       String(p["test_i1"]) + " " + \
-                       String(p["cica"]) + " " + \
-                       String(p["test_i2"]))""")
-  ScriptClip("""p = propGetAll() \
-    SubTitle("size:" + String(p.ArraySize()) + " " + \
-        String(p[0,1]) + " " + \
-        String(p[1,1]) + " " + \
-        String(p[2,1]), x=0, y=20)""")
-</div>
-''Example (read-write basic)''
-<div {{BoxWidthIndent|80|2}} >
-  ColorBars()
-  # just practicing with function objects
-  ScriptClip(function[](clip c) { c.Subtitle(String(current_frame)) })
-  # write frame properties with function object
-  ScriptClip("""propSetInt("frameprop_from_str",func(YPlaneMax))""")
-  # write frame properties with traditional script string
-  ScriptClip(function[](clip c) { propSetInt("frameluma_sc_func",func(AverageLuma)) })
-  # read frame properties (function object, string)
-  ScriptClip(function[](clip c) { SubTitle(string(propGetInt("frameprop_from_str")), y=20) })
-  ScriptClip("""SubTitle(string(propGetInt("frameluma_sc_func")), y=40)""")
-  return last
-</div>
-''Example (nearly everything)''
-<div {{BoxWidthIndent|92|2}} >
-  ColorBars(width=640, height=480, pixel_type="yv12", staticframes=true)
-  ScriptClip(function[](clip c) { propSetString("s",function[](clip c) { return "Hello " + string(current_frame) }) })
-  ScriptClip(function[](clip c) { propSetString("s",function[](clip c) { return "Hello array element #2 " }, mode=1) })
-  ScriptClip(function[](clip c) { propSetString("s",function[](clip c) { return "Hello array element #3 "}, mode=1 ) })
-  ScriptClip(function[](clip c) { propSetString("s2",function[](clip c) { return "Another property "} ) })
-  ScriptClip(function[](clip c) { propSetInt("s_int",function[](clip c) { return current_frame*1 }) })
-  ScriptClip(function[](clip c) { propSetInt("s_int",function[](clip c) { return current_frame*2 }, mode=1) })
-  ScriptClip(function[](clip c) { propSetInt("s_int",function[](clip c) { return current_frame*4 }, mode=1 ) })
-  ScriptClip(function[](clip c) { propSetFloat("s_float",function[](clip c) { return current_frame*1*3.14 }) })
-  ScriptClip(function[](clip c) { propSetFloat("s_float",function[](clip c) { return current_frame*2*3.14 }, mode=1) })
-  ScriptClip(function[](clip c) { propSetFloat("s_float",function[](clip c) { return current_frame*3*3.14 }, mode=1 ) })
-  ScriptClip(function[](clip c) { propSetArray("s_float_arr",function[](clip c) { return [1.1, 2.2] } ) })
-  ScriptClip(function[](clip c) { propSetArray("s_int_arr",function[](clip c) { return [-1,-2,-5] } ) })
-  ScriptClip(function[](clip c) { propSetArray("s_string",function[](clip c) { return ["ArrayElementS_1", "ArrayElementS_2"] } ) })
-  #ScriptClip("""propDelete("s")""")
-  ScriptClip(function[](clip c) {
-    y = 0
-    SubTitle("Prop Key count =" + String(propNumKeys), y=y)
-    y = y + 15
-    numKeys = propNumKeys() - 1
-    for ( i = 0 , numKeys) {
-      propName = propGetKeyByIndex(index = i)
-      propType = propGetType(propName)
-      SubTitle("#"+String(i) + " property: '" + propName + "', Type = " + String(propType) , y=y)
-      y = y + 15
-      for(j=0, propNumElements(propName) - 1) {
-        SubTitle("element #" + String(j) + ", size = " + String(propType == 3 ? propGetDataSize(propName, index=j) : 0) + ", Value = " + String(propGetAny(propName, index=j)), y = y)
-        #SubTitle("element #" + String(j) + " size = " + String(propType == 3 ? propGetDataSize(propName, index=j) : 0) + ", Value = " + String(propGetAny(propName, index=j)), y = y)
-        y = y + 15
-      }
-    }
-    return last
-  })
-  ScriptClip(function[](clip c) {
-    a = propGetAsArray("s")
-    y = 100
-    x = 400
-    SubTitle(string(a.ArraySize()), x=x, y=y)
-    for(i=0, a.ArraySize()-1) {
-      SubTitle("["+String(i)+"]="+ String(a[i]),x=x,y=y)
-      y = y + 15
-    }
-    return last
-  })
-  # get int array one pass
-  ScriptClip(function[](clip c) {
-    a = propGetAsArray("s_int")
-    y = 440
-    x = 400
-    SubTitle("Array size=" + string(a.ArraySize()), x=x, y=y)
-    y = y + 15
-    for(i=0, a.ArraySize()-1) {
-      SubTitle("["+String(i)+"]="+ String(a[i]),x=x,y=y)
-      y = y + 15
-    }
-    return last
-  })
-  # get float array one pass
-  ScriptClip(function[](clip c) {
-    a = propGetAsArray("s_float")
-    y = 440
-    x = 200
-    SubTitle("Array size=" + string(a.ArraySize()), x=x, y=y)
-    y = y + 15
-    for(i=0, a.ArraySize()-1) {
-      SubTitle("["+String(i)+"]="+ String(a[i]),x=x,y=y)
-      y = y + 15
-    }
-    return last
-  })
-  # get string array
-  ScriptClip(function[](clip c) {
-    a = propGetAsArray("s_string")
-    y = 440
-    x = 000
-    SubTitle("Array size=" + string(a.ArraySize()), x=x, y=y)
-    y = y + 15
-    for(i=0, a.ArraySize()-1) {
-      SubTitle("["+String(i)+"]="+ String(a[i]),x=x,y=y)
-      y = y + 15
-    }
-    return last
-  })
-</div>
-'''AviSynth 3.7.1''': allow propGetXXX property getter functions called as normal functions, outside runtime.<br>
-By default frame property values are read from frame#0 which index can be overridden by the offset parameter.
-''Example:''
-<div {{BoxWidthIndent|92|2}} >
-    Colorbars()
-    PropSet(last, "hello", 1) # Set to 1 for all frames
-    # Override to 2 with runtime function except for frameNo=1
-    ScriptClip("""if(current_frame!=1) {propSet("hello",2)}""")
-    n0 = propGetInt("hello") # same as propGetInt("hello",offset=0)
-    # or get the frame property from the Nth frame
-    n1 = propGetInt("hello",offset=1)
-    n2 = propGetInt("hello",offset=2)
-    # n0 and n2 is 2 (overridden in runtime)
-    # n1 will be 1 (keeps global setting)
-    SubTitle("n0/n1/n2=" + "{n0}/{n1}/{n2}".Format)
-</div>
 ==== Deleting properties ====
@@ Line 1,583: / Line 1,289: @@
 ==== Other property functions ====
 {{ScriptFunctionH5|propShow|{{AvsPluscon}}|propShow(clip, integer "size", bool "showtype")}}
-: This debug filter lists all frame properties on screen.
+: The filter is not a runtime function but is shown here. This debug filter lists all frame properties on screen.
-: Listing appears as a name = value list. Arrays values are displayed between [ and ]
+: Listing appears as a name = value list. Arrays values are put between [ and ]
 : Top line contains the number of properties. If no properties found, nothing is displayed.
 :* {{FuncArg|clip}} (required) specifies clip.
 :* {{FuncArg|integer}} "size" default(16), font size to use (the "Text" filter is used for display, sizes are of limited set)
 :* {{FuncArg|bool}} "showtype" default(false), if true, the data type in parenthesis appears next to the property key name
-{{ScriptFunctionH5|propGetDataSize|{{AvsPluscon}}|propGetDataSize(clip, string key_name [, integer "index", integer "offset"])}}
-: returns the size of the string or underlying data array
-{{ScriptFunctionH5|propNumElements|{{AvsPluscon}}|propNumElements(clip, string key_name [, integer "offset"])}}
-: returns the array size of a given property. 1=single value
-{{ScriptFunctionH5|propNumKeys|{{AvsPluscon}}|propNumKeys(clip, [, integer "offset"])}}
-: returns number of entries (keys) for a frame
-{{ScriptFunctionH5|propGetKeyByIndex|{{AvsPluscon}}|propGetKeyByIndex(clip, integer "index" [, integer "offset")}}
-: returns the key name for the Nth property (zero based, 0<=index<propNumKeys)
-{{ScriptFunctionH5|propGetType|{{AvsPluscon}}(v3.7.0)|propGetType(clip, string key_name [, integer "offset"])}}
-: returns the type of the given key
-::*unset: 0
-::*integer: 1
-::*float: 2
-::*string: 3
-::*clip: 4
-::*frame: 5
-{{ScriptFunctionH5|propCopy|{{AvsPluscon}}(v3.7.1)|propCopy(clip, clip [,bool "merge"])}}
-: Copies the frame properties of the second clip to the first.
-::*Parameter 'merge' (default false):
-:::*when false: exact copy (original target properties will be lost)
-:::*when true: keeps original properties, appends all parameters from source but overwrite if a parameter with the same name already exists.
 == Script functions ==
@@ Line 2,082: / Line 1,761: @@
   isAtLeast3_5_1 = IsVersionOrGreater(3,5,1)
 </div>
-</div>
-== Array functions ==
-<div style="max-width:62em" >
-: {{AvsPluscon}}
-: Array manipulator functions for AviSynth+.
-{{ScriptFunctionH5|ArrayAdd||ArrayAdd(array_to_mod, value_to_append [, index1, index2, index3...])}}
-: Appends value to the end of an array or its subarray
-: Returns a new array with value_to_append appended to array_to_mod (1D array) or array_to_mod[index1 (, index2, index3...)] (multi-dimensional array).
-: Original array (as with the other functions) remains untouched.
-{{ScriptFunctionH5|ArrayDel||ArrayDel(array_to_mod, index1 (, index2, index3...])}}
-: Returns a new array in which the requested position was deleted.
-: Original array (as with the other functions) remains untouched.
-{{ScriptFunctionH5|ArrayIns||ArrayIns (array_to_mod, value_to_insert, index1 [, index2, index3...])}}
-: Insert a value into an array or into its subarray.
-: Returns a new array with value_to_insert inserted into array_to_mod (1D array) or array_to_mod[index1 (, index2, index3...)] (multi-dimensional array)
-: The indexes point to the insertion point. Index 0 will insert at the beginning of the array.
-: Index (ArraySize) will insert after the last element (same as ArrayAdd - append)
-: Original array (as with the other functions) remains untouched.
-{{ScriptFunctionH5|ArraySet||ArraySet(array_to_mod, replacement_value, index1 [, index2, index3...])}}
-: Returns a new array with array_to_mod[index1 (, index2, index3...)] = replacement_value
-: Original array (as with the other functions) remains untouched.
-''Examples:''
-<div {{BoxWidthIndent|56|2}} >
- ColorbarsHD()
- # array indexes are zero based
- a = []
- a=ArrayAdd(a,[1,2]) # <nowiki>[[1,2]]</nowiki>
- a=ArrayIns(a,3,0) # [3,[1,2]]
- a=ArrayAdd(a,"s1") # [3,[1,2],"s1"]
- a=ArrayAdd(a,"s2") # [3,[1,2],"s1","s2"]
- a=ArrayDel(a,2) # [3,[1,2],"s2"]
- a=ArraySet(a,"g",1,0) # [3,["g",2],"s2"]
- a=ArrayAdd(a,"h",1) # [3,["g",2,"h"],"s2"]
- a=ArrayAdd(a,[10,11,12],1) # append to (1) -> [3,["g",2,"h",[10,11,12]],"s2"]
- a=ArrayDel(a,1,3,0) # del from (1,3,0) -> [3,["g",2,"h",[11,12]],"s2"]
- a=ArrayAdd(a,"added") # [3,["g",2,"h",[11,12]],"s2","added"]
- a=ArrayAdd(a,["yet","another","sub"]) # [3,["g",2,"h",[11,12]],"s2","added",["yet","another","sub"]]
- x=a[0] #3
- x=a[1,0] #g
- x=a[1,2] #h
- x=a[1,3,1] #12
- x=a[3] #"added"
- x=a[4,1] #"another"
- SubTitle("x = " + String(x) + " Size=" + String(a.ArraySize()))
-</div>
-: For more examples see the [[User_defined_script_functions#Facts_about_user_defined_script_functions|Facts about user defined script functions]] section.
 </div>