Expr - Revision history

Reel.Deal: add link to avs+ documentation

2022-09-17T18:55:43Z

add link to avs+ documentation

Pinterf: /* Expr language/RPN elements */ fix formatter missing end

2021-12-09T13:09:49Z

‎Expr language/RPN elements: fix formatter missing end

Pinterf: /* Changes */ mention special full scale chroma method

2021-12-09T13:07:45Z

‎Changes: mention special full scale chroma method

Pinterf: /* Auto-scale inputs with "scale_inputs" */ some missing f32 mentioning, chroma mode

2021-12-09T13:05:41Z

‎Auto-scale inputs with "scale_inputs": some missing f32 mentioning, chroma mode

Pinterf: /* Changes */ lut in 3.7.1

2021-12-09T12:51:37Z

‎Changes: lut in 3.7.1

Pinterf: /* Syntax and Parameters */ lut mode

2021-12-09T12:51:01Z

‎Syntax and Parameters: lut mode

Pinterf: /* Changes */ Expr 3.7.1

2021-12-09T11:30:50Z

‎Changes: Expr 3.7.1

Pinterf: Expr: allow f32 in all autoscale

2021-12-09T11:28:14Z

Expr: allow f32 in all autoscale

Pinterf: /* Expr language/RPN elements */ New functions sgn and neg

2021-12-09T11:22:24Z

‎Expr language/RPN elements: New functions sgn and neg

Pinterf: /* Expr language/RPN elements */ sin and cos to SIMD, new atan2

2021-12-09T11:18:09Z

‎Expr language/RPN elements: sin and cos to SIMD, new atan2

@@ Line 1: / Line 1: @@
 <div style="max-width:82em; min-width:42em;" >
 {{AvsPlusFilter}}
 __NOTOC__

@@ Line 119: / Line 119: @@
 :* Function: <code>sgn</code> simple signum function -1 if x<0; 0 when x==0; 1 if x>0
 :* Function: <code>clip</code> three operand function for clipping. Example: <code>x 16 240 clip</code> means min((max(x,16),240)
-:* Functions: <code>sin cos atan2 tan asin acos atan</code><p>On Intel x86/x64 the functions <code>sin</code>, <code>cos</code> and <code>atan2</code> have SSE2/AVX2 optimization, the others have not (they make the whole expression to evaluate without SIMD optimization)
+:* Functions: <code>sin cos atan2 tan asin acos atan</code><p>On Intel x86/x64 the functions <code>sin</code>, <code>cos</code> and <code>atan2</code> have SSE2/AVX2 optimization, the others have not (they make the whole expression to evaluate without SIMD optimization)</p>
 :* Functions: <code>round, floor, ceil, trunc</code> operators (nearest integer - banker's rounding, round down, round up, round to zero)<p>On Intel builds acceleration requires at least SSE4.1 capable processor or else the whole expression is running in C mode.</p>
 :* Logical: <code> > < = >= <= and or xor not == & | !=</code> (synonyms: <code>==</code> and <code>=</code>, <code>&</code> and <code>and</code>, <code>|</code> and <code>or</code>)

@@ Line 299: / Line 299: @@
 Enhanced: allow ‘f32’ as internal autoscale target besides integer i8..i16<br>
 lut (Lookup table) support 1D and 2D<br>
 |-
 | r3.5

@@ Line 203: / Line 203: @@
 : By default the internal conversion target is 8 bits, so old expressions written for 8 bit videos will probably work.
-: This internal working bit-depth can be overwritten by the i8, i10, i12, i14, i16 specifiers.
+: This internal working bit-depth can be overwritten by the i8, i10, i12, i14, i16 and f32 specifiers.
 : When using autoscale mode, scaleb and scalef keywords are meaningless for 8-16 bits, because there is nothing to scale. 32 bit (float) values will be scaled however when "float", "floatUV", "all", "allf" is specified.
@@ Line 209: / Line 209: @@
 : How it works:
-:*8-32 bit inputs ar all scaled to a common bit depth value, which bit depth is 8 by default and can be set to 10, 12, 14 and 16 bits by the 'i10'..'i16' keywords.<br>
+:*8-32 bit inputs ar all scaled to a common bit depth value, which bit depth is 8 by default and can be set to 10, 12, 14, 16 or 32 bits by the 'i10'..'i16','f32' keywords.<br>
 :For example: scale_inputs="all" converts any inputs to 8 bit range. No truncation occurs however (no precision loss), because even a 16 bit data is converted to 8 bit in floating point precision, using division by 256.0 (2^16/2^8).
 :So the conversion is _not_ a simple shift-right-8 in the integer domain, which would lose precision.
-:*Calculates expression (like in masktools2 mt_lut, mt_lutxy, mt_lutxyz and mt_lutxyza do)
+:*Calculates expression
 :*Scales the internal result back to the original video bit depth.<br>Clamping (clipping to valid range) and converting to an integer output (if applicable) occurs here.
@@ Line 221: / Line 221: @@
 ::Let's see a 16bit input in "all" and "allf" mode (target is the default 8 bits)
 ::Limited range 16->8 bits conversion has a factor of 1/256.0 (Instead of shift right 8 in integer domain, float-division is used or else it would lose presision)
-::Full range 16->8 bits conversion has a factor of 255.0/65535
+::Full range 16->8 bits conversion has a factor of 255.0/65535 (chroma is a bit different, since it is converted by moving into signed domain and back such as in (x-32768)*(127/32767)+128)
 ::Using bit shifts (really it's division and multiplication by 2^8=256.0):
-::<code>result = calculate_lut_value(input / 256.0) * 256.0</code>
+::<code>result = calculate_value(input / 256.0) * 256.0</code>
 ::Full scale 16-8-16 bit mode ('intf', 'allf'):
-::<code>result = calculate_lut_value(input / 65535.0 * 255.0 ) / 255.0 * 65535.0</code>
+::<code>result = calculate_value(input / 65535.0 * 255.0 ) / 255.0 * 65535.0</code>
 ::Use scale_inputs = "all" ("int", "float") for YUV videos with 'limited' range e.g. in 8 bits: Y=16..235, UV=16..240).
 ::Use scale_inputs = "allf" (intf, floatf) for RGB or YUV videos with 'full' range e.g. in 8 bits: channels 0..255.

@@ Line 297: / Line 297: @@
 new: neg, sgn<br>
 Enhanced: allow ‘f32’ as internal autoscale target besides integer i8..i16<br>
 |-
 | r3.5

@@ Line 12: / Line 12: @@
 {{FuncDef
 |Expr( [clip ''clip''[, ...], string ''exp''[, ...], string ''format'',<br>
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool ''optAvx2'', bool ''optSingleMode'', bool ''optSSE2'', string ''scale_inputs'', bool ''clamp_float'', bool ''clamp_float_UV''] )
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; bool ''optAvx2'', bool ''optSingleMode'', bool ''optSSE2'', string ''scale_inputs'', bool ''clamp_float'', bool ''clamp_float_UV'', int ''lut''] )
 }}
@@ Line 48: / Line 48: @@
 :{{Par2|scale_inputs|string|"none"}}
-:: Autoscale any input bit depths to 8-16 bit for internal expression use, the conversion method is either full range (stretch) or limited YUV range (like bit shift). Feature is similar to the one in masktools2 v2.2.15
+:: Autoscale any input bit depths to 8-16 bit integer or 32 bit float for internal expression use, the conversion method is either full range (stretch) or limited YUV range (like bit shift). Feature is similar to the one in masktools2 v2.2.15
 :: The primary reason of this feature is the "easy" usage of formerly written expressions optimized for 8 bits.
 ::*"int" : scales limited range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16' and 'f32')
@@ Line 72: / Line 72: @@
 :: this parameter affects clamping of chroma planes: chroma is clamped between 0..1.0 instead of -0.5..0.5.
 :: Default false: as usual, 32 bit float pixels are not clamped
 </div>

@@ Line 275: / Line 275: @@
 <div style="max-width:62em; min-width:42em;" >
 {|border=1 cellspacing=1 cellpadding=4
 |-
 | r3.5

@@ Line 50: / Line 50: @@
 :: Autoscale any input bit depths to 8-16 bit for internal expression use, the conversion method is either full range (stretch) or limited YUV range (like bit shift). Feature is similar to the one in masktools2 v2.2.15
 :: The primary reason of this feature is the "easy" usage of formerly written expressions optimized for 8 bits.
-::*"int" : scales limited range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16')
+::*"int" : scales limited range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16' and 'f32')
-::*"intf": scales full range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16')
+::*"intf": scales full range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16' and 'f32')
-::*"float" or "floatf" : only scales 32 bit float format to 8 bit range (or bit depth specified by 'i8'..'i16')
+::*"float" or "floatf" : only scales 32 bit float format to 8 bit range (or bit depth specified by 'i8'..'i16' and 'f32')
 ::*"floatUV": (since v3.5) chroma pre and post shift by 0.5 for 32 bit float pixels, thus having them in the range of 0..1 instead of -0.5..+0.5 during Expr evaluation
-::*"all": scales videos to 8 (or bit depth specified by 'i8'..'i16') - conversion uses limited_range logic (mul/div by two's power)
+::*"all": scales videos to 8 (or bit depth specified by 'i8'..'i16' and 'f32') - conversion uses limited_range logic (mul/div by two's power)
-::*"allf": scales videos to 8 (or bit depth specified by 'i8'..'i16') - conversion uses full scale logic (stretch)
+::*"allf": scales videos to 8 (or bit depth specified by 'i8'..'i16' and 'f32') - conversion uses full scale logic (stretch)
 ::*"none": no magic
 :: E.g. scale_inputs="float" will automatically convert 32 bit float input to 8 bit range (but keeps the floating point precision)
-:: The default 8 bit target range can be overridden by the i10 .. i16 specifiers at the beginning of the expression string.
+:: The default 8 bit target range can be overridden by the i10 .. i16 or f32 specifiers at the beginning of the expression string.
 :: The script inside will treat the clip as a 8 bit one. This only affects the internal calculations, the output is properly scaled back.
 :: Note: ymin, ymax, cmin, cmax, range_min, range_max, range_half and range_size internal variables are changed accordingly (this behaviour was fixed in Avs+ > r2900)
@@ Line 175: / Line 175: @@
 ==== Auto-scale inputs with "scale_inputs" ====
-: Autoscale works by converting any input bit depths to a common 8-16 bit format for internal expression use, the conversion method is either full range or limited YUV range. Feature is similar to the one in masktools2 v2.2.15
+: Autoscale works by converting any input bit depths to a common 8-16 integer or 32 bit float bit format for internal expression use, the conversion method is either full range or limited YUV range. Feature is similar to the one in masktools2 v2.2.15
 : The primary reason of this feature is the "easy" usage of formerly written expressions optimized for 8 bits.
 : Possible values for scale_inputs
-::* "int" : scales limited range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16')
+::* "int" : scales limited range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16','f32')
-::* "intf": scales full range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16')
+::* "intf": scales full range videos, only integer formats (8-16bits) to 8 (or bit depth specified by 'i8'..'i16','f32')
-::* "float" or "floatf" : only scales 32 bit float format to 8 bit range (or bit depth specified by 'i8'..'i16')
+::* "float" or "floatf" : only scales 32 bit float format to 8 bit range (or bit depth specified by 'i8'..'i16','f32')
 ::* "floatUV": (since v3.5) chroma pre and post shift by 0.5 for 32 bit float pixels, thus having them in the range of 0..1 instead of -0.5..+0.5 during Expr evaluation
-::* "all": scales videos to 8 (or bit depth specified by 'i8'..'i16') - conversion uses limited_range logic (mul/div by two's power)
+::* "all": scales videos to 8 (or bit depth specified by 'i8'..'i16','f32') - conversion uses limited_range logic (mul/div by two's power)
-::* "allf": scales videos to 8 (or bit depth specified by 'i8'..'i16') - conversion uses full scale logic (stretch)
+::* "allf": scales videos to 8 (or bit depth specified by 'i8'..'i16','f32') - conversion uses full scale logic (stretch)
 ::* "none": no magic

@@ Line 103: / Line 103: @@
 :* <code>%</code> (modulo), like fmod. Example: <code>result = x - trunc(x/d)*d</code>. Note: the internal 32-bit float can hold only a 24 bit integer number (approximately)
 :* Math constant: <code>pi</code>
-:* Functions: <code>min, max, sqrt, abs, neg, exp, log, pow ^</code> (synonyms: <code>pow</code> and <code></code>)
+:* Functions: <code>min, max, sqrt, abs, exp, log, pow ^</code> (synonyms: <code>pow</code> and <code></code>)
 :* Function: <code>clip</code> three operand function for clipping. Example: <code>x 16 240 clip</code> means min((max(x,16),240)
 :* Functions: <code>sin cos atan2 tan asin acos atan</code><p>On Intel x86/x64 the functions <code>sin</code>, <code>cos</code> and <code>atan2</code> have SSE2/AVX2 optimization, the others have not (they make the whole expression to evaluate without SIMD optimization)