Reel.Deal: archived link

2016-04-21T13:11:52Z

archived link

← Older revision		Revision as of 15:11, 21 April 2016
Line 3:		Line 3:
	\| mawen1250		\| mawen1250
	\| v1.2		\| v1.2
	\| [http://www.nmm-hd.org/upload/get~8y1IjaaqvoI/Resize8_v1.2.avsi Resize8_v1.2.avsi]		\| [http://web.archive.org/web/20150911013350/http://www.nmm-hd.org/upload/get~8y1IjaaqvoI/Resize8_v1.2.avsi Resize8_v1.2.avsi]
	\| Resize		\| Resize
	\|		\|

Reel.Deal: space

2016-03-04T12:58:21Z

space

← Older revision		Revision as of 14:58, 4 March 2016
Line 16:		Line 16:

	It also includes {{Template:FuncDef3\|Resize8_Separate()}}, this function processes each plane's source position separately, mainly designed for fixing center shift caused by nnedi3, eedi3, eedi2, etc. Note that it doesn't correct chroma placement, so usually the result should be resized back to the original size, such as what many [[anti aliasing]] functions do. Adaptive anti-ringing algorithm is supported		It also includes {{Template:FuncDef3\|Resize8_Separate()}}, this function processes each plane's source position separately, mainly designed for fixing center shift caused by nnedi3, eedi3, eedi2, etc. Note that it doesn't correct chroma placement, so usually the result should be resized back to the original size, such as what many [[anti aliasing]] functions do. Adaptive anti-ringing algorithm is supported

	<br>		<br>
	<br>		<br>

Reel.Deal: space

2016-03-04T12:57:52Z

space

← Older revision		Revision as of 14:57, 4 March 2016
Line 1:		Line 1:
	{{FilterCat4\|External_filters\|Scripts\|Adjustment_filters\|Resizers}}		{{FilterCat4\|External_filters\|Scripts\|Adjustment_filters\|Resizers}}

	{{Filter3		{{Filter3
	\| mawen1250		\| mawen1250
Line 8:		Line 7:
	\|		\|
	\|6=[http://www.nmm-hd.org/newbbs/viewtopic.php?t=1323 NMM-HD] [Chinese]}}		\|6=[http://www.nmm-hd.org/newbbs/viewtopic.php?t=1323 NMM-HD] [Chinese]}}
	~~<br>~~
	== Description ==		== Description ==
	{{Template:FuncDef3\|Resize8()}} works just like [[Resize\|AviSynth's internal resizers]] but with some extra features:		{{Template:FuncDef3\|Resize8()}} works just like [[Resize\|AviSynth's internal resizers]] but with some extra features:

Reel.Deal: /* Examples */ corrections

2015-09-11T03:44:03Z

Examples: corrections

← Older revision		Revision as of 05:44, 11 September 2015
Line 102:		Line 102:
	Correctly scale a YV12 source with MPEG2 chroma placement:		Correctly scale a YV12 source with MPEG2 chroma placement:
	[[AviSource]]("Blah.avi")		[[AviSource]]("Blah.avi")
	Resize8(1280, 720, cplace="MPEG2")		Resize8(target_width=1280, target_height=720, cplace="MPEG2") # Identical to Resize8(1280,720)

	Upscale using adaptive anti-ringing:		Upscale using adaptive anti-ringing:
	~~[[AviSource]]("Blah.avi")~~		Resize8(target_width=1280, target_height=720, noring=true)
	Resize8(1280, 720~~, cplace="MPEG2"~~, noring=true)
	<br>		<br>

	== Changelog ==		== Changelog ==
	Version Date Changes<br>		Version Date Changes<br>

Reel.Deal: almost done, a few things missing

2015-09-11T03:34:54Z

almost done, a few things missing

Show changes

Raffriff42: preliminary, copy of script /w no formatting

2015-09-10T04:52:40Z

preliminary, copy of script /w no formatting

New page

{{FilterCat4|External_filters|Scripts|Adjustment_filters|Resizers}}
{{Filter5
| 1=[http://www.nmm-hd.org/newbbs/memberlist.php?mode=viewprofile&u=479&sid=ff62d0f6c22fcfdbe97b53c8351429bc mawen1250]
| 2=1.2
| 3=[https://www.nmm-hd.org/newbbs/viewtopic.php?f=7&t=1323 Web page (Japanese)]
| 4=[https://translate.google.com/translate?sl=auto&tl=en&js=y&prev=_t&hl=en&ie=UTF-8&u=https%3A%2F%2Fwww.nmm-hd.org%2Fnewbbs%2Fviewtopic.php%3Ff%3D7%26t%3D1323&edit-text= (Google Translation)]
| 5=
| 6=Resizers
| 7=
| 8=[http://forum.doom9.org/showthread.php?p=1654726#post1654726 doom9.org]
}}
==Description==
Fixes chroma shift issues of AviSynth's resizers. Required by [[Xaa]]

==Script==
<font size="2"><pre>
###### Resize8 v1.2 ###### by mawen1250 ###### 2015.02.23 ######
###### Requirements: AviSynth v2.6+, RgTools 0.92.1 or Repair v1.0pre ######
###### Accept Y8, YV12, YV16, YV24, RGB24, RGB32 input, use AviSynth resizers for scaling ######
###### Resize8() is the same as normal resizer with some extra features. ######
###### Chroma placement is correctly handled by it, while AviSynth resizers doesn't. ######
###### Resize8_Separate() processes each plane's source position separately, ######
###### mainly designed for fixing center shift caused by nnedi3, eedi3, eedi2, etc. ######
###### Note that it doesn't correct chroma placement, so usually the result should be ######
###### resized back to the original size, such as what many AA functions do. ######
###### Adaptive anti-ringing algorithm is supported ######
###### Scaling kernel for luma and chroma can be adjusted separately ######
######
###### All the parameters with "_c" represents U/V plane in YV12/YV16/YV24 or Alpha plane in RGB32.
###### The ones without "_c" represents Y plane in Y8/YV12/YV16/YV24 or R/G/B plane in RGB24/RGB32.

Function Resize8(clip input, int "target_width", int "target_height", float "src_left", float "src_top",
\ float "src_width", float "src_height",
\ string "kernel", string "kernel_c", float "a1", float "a2", float "a1_c", float "a2_c",
\ val "noring", val "noring_c", string "cplace", bool "Y", bool "U", bool "V", bool "Alpha")
{
# Properties of input clip
sCSP = input.GetCSP()
IsY8 = sCSP == "Y8"
IsRGB = LeftStr(sCSP, 3) == "RGB"
oCSP = IsY8 || IsRGB ? "YV24" : sCSP
Assert(sCSP=="Y8" || sCSP=="YV12" || sCSP=="YV16" || sCSP=="YV24" || sCSP=="RGB24" || sCSP=="RGB32", """Resize8: only accept Y8, YV12, YV16, YV24, RGB24, RGB32 input""")

sw = input.Width ()
sh = input.Height()
swc = oCSP=="YV24" ? sw : sw/2
shc = oCSP=="YV12" ? sh/2 : sh

# Parameters for size transform
ow = Default(target_width, sw)
oh = Default(target_height, sh)
owc = oCSP=="YV24" ? ow : ow/2
ohc = oCSP=="YV12" ? oh/2 : oh
Assert(!(oCSP=="YV16" && ow!=owc*2), """Resize8: width of YV16 output clip must be MOD2!""")
Assert(!(oCSP=="YV12" && ow!=owc*2), """Resize8: width of YV12 output clip must be MOD2!""")
Assert(!(oCSP=="YV12" && oh!=ohc*2), """Resize8: height of YV12 output clip must be MOD2!""")

src_l = Default(src_left, 0 )
src_t = Default(src_top, 0 )
src_w = Default(src_width, sw )
src_h = Default(src_height, sh )

src_w = src_w<=0 ? sw-src_l+src_w : src_w
src_h = src_h<=0 ? sh-src_t+src_h : src_h
src_lc = oCSP=="YV24" ? src_l : src_l/2.
src_tc = oCSP=="YV12" ? src_t/2. : src_t
src_wc = oCSP=="YV24" ? src_w : src_w/2.
src_hc = oCSP=="YV12" ? src_h/2. : src_h

# Process
return Resize8_main(input, ow, oh, owc, ohc, src_l, src_t, src_lc, src_tc, src_w, src_h, src_wc, src_hc,
\ kernel, kernel_c, a1, a2, a1_c, a2_c, noring, noring_c, cplace, Y, U, V, Alpha)
}

Function Resize8_Separate(clip input, int "target_width", int "target_height", float "src_left", float "src_top",
\ float "src_width", float "src_height",
\ string "kernel", string "kernel_c", float "a1", float "a2", float "a1_c", float "a2_c",
\ val "noring", val "noring_c", bool "Y", bool "U", bool "V", bool "Alpha")
{
# Properties of input clip
sCSP = input.GetCSP()
IsY8 = sCSP == "Y8"
IsRGB = LeftStr(sCSP, 3) == "RGB"
oCSP = IsY8 || IsRGB ? "YV24" : sCSP
Assert(sCSP=="Y8" || sCSP=="YV12" || sCSP=="YV16" || sCSP=="YV24" || sCSP=="RGB24" || sCSP=="RGB32", """Resize8: only accept Y8, YV12, YV16, YV24, RGB24, RGB32 input""")

sw = input.Width ()
sh = input.Height()
swc = oCSP=="YV24" ? sw : sw/2
shc = oCSP=="YV12" ? sh/2 : sh

# Parameters for size transform
ow = Default(target_width, sw)
oh = Default(target_height, sh)
owc = oCSP=="YV24" ? ow : ow/2
ohc = oCSP=="YV12" ? oh/2 : oh
Assert(!(oCSP=="YV16" && ow!=owc*2), """Resize8: width of YV16 output clip must be MOD2!""")
Assert(!(oCSP=="YV12" && ow!=owc*2), """Resize8: width of YV12 output clip must be MOD2!""")
Assert(!(oCSP=="YV12" && oh!=ohc*2), """Resize8: height of YV12 output clip must be MOD2!""")

src_l = Default(src_left, 0 )
src_t = Default(src_top, 0 )
src_w = Default(src_width, sw )
src_h = Default(src_height, sh )

src_w = src_w<=0 ? sw-src_l+src_w : src_w
src_h = src_h<=0 ? sh-src_t+src_h : src_h
src_r = sw - src_w - src_l
src_b = sh - src_h - src_t
src_lc = src_l
src_tc = src_t
src_wc = swc - src_l - src_r
src_hc = shc - src_t - src_b

# Process
return Resize8_main(input, ow, oh, owc, ohc, src_l, src_t, src_lc, src_tc, src_w, src_h, src_wc, src_hc,
\ kernel, kernel_c, a1, a2, a1_c, a2_c, noring, noring_c, "MPEG1", Y, U, V, Alpha)
}

Function Resize8_main(clip input, int "ow", int "oh", int "owc", int "ohc",
\ float "src_l", float "src_t", float "src_lc", float "src_tc",
\ float "src_w", float "src_h", float "src_wc", float "src_hc",
\ string "kernel", string "kernel_c", float "a1", float "a2", float "a1_c", float "a2_c",
\ val "noring", val "noring_c", string "cplace", bool "Y", bool "U", bool "V", bool "Alpha")
{
# All the parameters with "_c" affects U/V plane in YV12/YV16/YV24 or Alpha plane in RGB32.
# The ones without "_c" affects Y plane in Y8/YV12/YV16/YV24 or R/G/B plane in RGB24/RGB32.

# Properties of input clip
sCSP = input.GetCSP()
IsY8 = sCSP == "Y8"
IsRGB = LeftStr(sCSP, 3) == "RGB"
oCSP = IsY8 || IsRGB ? "YV24" : sCSP
Assert(sCSP=="Y8" || sCSP=="YV12" || sCSP=="YV16" || sCSP=="YV24" || sCSP=="RGB24" || sCSP=="RGB32", """Resize8: only accept Y8, YV12, YV16, YV24, RGB24, RGB32 input""")

sw = input.Width ()
sh = input.Height()
swc = oCSP=="YV24" ? sw : sw/2
shc = oCSP=="YV12" ? sh/2 : sh

# Parameters for resampler
yhratio = float(ow ) / float(src_w )
yvratio = float(oh ) / float(src_h )
chratio = float(owc) / float(src_wc)
cvratio = float(ohc) / float(src_hc)
yup = yhratio * yvratio>1
cup = chratio * cvratio>1

kernel = Default(kernel, yup ? "Lanczos4" : "Spline36")
kernel_c = Default(kernel_c, cup ? "Lanczos" : "Spline36")
# "kernel" sets resizing kernel for luma, "kernel_c" sets resizing kernel for chroma
# Supported kernels: Bicubic, Catmull-Rom, Hermite, Mitchell-Netravali, Robidoux, SoftCubic, SoftCubicXX (XX represents softness:[50-100])
# Point, Bilinear, Gauss/Gaussian, Sinc
# Blankman, Blankman2, Blankman3, Blankman4
# Lanczos, Lanczos2, Lanczos3, Lanczos4
# Spline16, Spline36, Spline64
# By default, "Lanczos4" is set for luma upscaling, "Lanczos" is set for chroma upscaling, "Spline36" is set for luma/chroma downscaling.
kernel = RightStr(kernel , 6) == "Resize" ? LeftStr(kernel , StrLen(kernel )-6) : kernel
kernel_c = RightStr(kernel_c, 6) == "Resize" ? LeftStr(kernel_c, StrLen(kernel_c)-6) : kernel_c

defa1 = Defined(a1)
defa2 = Defined(a2)
a1 = defa1 ? a1 : Resize8_undef()
a2 = defa2 ? a2 : Resize8_undef()
a1_c = Defined(a1_c) ? a1_c : defa1 && kernel==kernel_c ? a1 : Resize8_undef()
a2_c = Defined(a2_c) ? a2_c : defa2 && kernel==kernel_c ? a2 : Resize8_undef()
# "a1", "a2", sets parameters for resizer used in luma
# "a1_c", "a2_c" sets parameters for resizer used in chroma
# "a1" represents "b" and "a2" represents "c" for kernel "Bicubic" (default: b = 1/3., c = 1/3.)
# "a1" represents "taps" and "a2" do nothing for kernel "Blackman" (default: taps=4, 1<=taps<=100)
# "a1" represents "taps" and "a2" do nothing for kernel "Lanczos" (default: taps=3, 1<=taps<=100)
# "a1" represents "taps" and "a2" do nothing for kernel "Sinc" (default: taps=4, 1<=taps<= 20)
# "a1" represents "p" and "a2" do nothing for kernel "Gauss" (default: p=30, 1<= p <=100)
# "a1" represents "soft" and "a2" do nothing for kernel "SoftCubic" (default: soft=75, 50<=soft<=100)
# for kernel "SoftCubicXX", "XX" represents "soft" and "a1"/"a2" do nothing
# "a1" do nothing and "a2" do nothing for the rest kernels supported by Resize8:
# "Catmull-Rom", "Hermite", "Mitchell-Netravali", "Robidoux", "Bilinear", "Point", "Spline16", "Spline36", "Spline64"

# Parameters for anti-ringing algorithm
nrkn = kernel == "Point" || kernel == "Bilinear" || kernel == "Gauss" || kernel == "Gaussian" || kernel == "Hermite" || LeftStr(kernel , 9) == "SoftCubic"
nrkn_c = kernel_c == "Point" || kernel_c == "Bilinear" || kernel_c == "Gauss" || kernel_c == "Gaussian" || kernel_c == "Hermite" || LeftStr(kernel_c, 9) == "SoftCubic"
noring = Default(noring, nrkn ? False : True )
noring_c = Default(noring_c, nrkn_c ? False : noring)
# "noring" & "noring_c" can be Bool or Float
# By default, we don't use anti-ringing algorithm for kernels "Point","Bilinear","Gauss"/"Gaussian","Hermite","SoftCubic".
# When "noring" or "noring_c" is True, adaptive anti-ringing is enabled, when no upscaling is applied, anti-ringing is also automatically disabled.
# For the default kernel of upscaling, kernel="Lanczos4"+noring=True is applied for luma, kernel_c="Lanczos"+noring_c=True is applied for chroma.
# For the default kernel of downscaling, kernel="Spline36"+noring=True is applied for luma/chroma, but the adaptive anti-ringing will turn off anti-ringing.
#
# Use repair to remove ringing introduced from resizer
# noring >= 1 : completely use non-ringing repaired clip
# 0 < noring < 1 : noring is the weight of non-ringing repaired clip for merging with normally upscaled clip
# noring <= 0 or False : do not use non-ringing repaired clip
# noring == True : adapt the weight of non-ringing repaired clip according to input and output resolution
Assert(IsFloat(noring ) || IsBool(noring ), """Resize8: "noring" should be either bool or float!""")
Assert(IsFloat(noring_c) || IsBool(noring_c), """Resize8: "noring_c" should be either bool or float!""")

# Parameters for colorspace
cplace = Default(cplace, "MPEG2")
# Placement of the chroma subsamples. Can be one of these strings:
# "MPEG1": 4:2:0 subsampling used in MPEG-1. Chroma samples are located on the center of each group of 4 pixels.
# "MPEG2": Subsampling used in MPEG-2 4:2:x. Chroma samples are located on the left pixel column of the group.

Yt = Default(Y, True )
Ut = Default(U, True )
Vt = Default(V, True )
At = Default(Alpha, True )
# Control whether to process Y/U/V plane(or R/G/B/A plane for RGB24/RGB32 input)
Ut = IsY8 ? False : Ut
Vt = IsY8 ? False : Vt
At = sCSP=="RGB32" ? At : False

# Chroma placement of MPEG-2 YV12(4:2:0) and YV16(4:2:2) is left-aligned,
# thus center-aligned resizer can cause chroma shift after scaling.
# Positive value means left-shift/top-shift, negetive value means right-shift/bottom-shift.
# chshifta = oCSP=="YV24" || cplace=="MPEG1" ? 0 : 0.25-0.25*chratio # Chroma horizontal shift after scaling
# cvshifta = oCSP=="YV24" || cplace=="MPEG1" ? 0 : 0 # Chroma vertical shift after scaling
# chshiftb = oCSP=="YV24" || cplace=="MPEG1" ? 0 : 0.25/chratio-0.25 # Chroma horizontal shift before scaling equivalent to that after scaling
# cvshiftb = oCSP=="YV24" || cplace=="MPEG1" ? 0 : 0 # Chroma vertical shift before scaling equivalent to that after scaling

# So we apply shift before scaling to fix the chroma shift
chfix = oCSP=="YV24" || cplace=="MPEG1" ? 0 : 0.25-0.25/chratio # Chroma horizontal shift fixing before scaling
cvfix = oCSP=="YV24" || cplace=="MPEG1" ? 0 : 0 # Chroma vertical shift fixing before scaling

# Weight calculation of adaptive anti-ringing algorithm
res_mul = yhratio * yvratio
res_mul = min(max(res_mul , 1), 2.25)
nr_wght = IsFloat(noring ) ? noring
\ : noring == True ? Spline(res_mul , 1, 0, 2.25, 1, 3.5, 0, True)
\ : 0
nr_wght = min(max(nr_wght , 0), 1)

res_mul_c = chratio * cvratio
res_mul_c = min(max(res_mul_c, 1), 2.25)
nr_wght_c = IsFloat(noring_c) ? noring_c
\ : noring_c == True ? Spline(res_mul_c, 1, 0, 2.25, 1, 3.5, 0, True)
\ : 0
nr_wght_c = min(max(nr_wght_c, 0), 1)

# Apply resize
IsY8 ? \
Eval("""
Ys = input

Yo = Yt ? Ys."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , kernel , a1 , a2 )+""" : NOP()

Yg = Yt && nr_wght > 0 ? Ys."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , "Gauss" , 100 )+""" : NOP()

Yr = Yt && nr_wght > 0 ? Yo.Resize8_Repair(Yg, 1, -1) : NOP()

Ym = Yt ? nr_wght == 1 ? Yr : nr_wght > 0 ? Yo.Merge(Yr, nr_wght ) : Yo : Ys.BlankClip(width=ow , height=oh , color_yuv=$808080)

res = Ym
""") : \
IsRGB ? \
Eval("""
As = At ? input.ShowAlpha("Y8") : NOP()
Rs = input.ShowRed ("Y8")
Gs = input.ShowGreen("Y8")
Bs = input.ShowBlue ("Y8")

Ao = At ? As."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , kernel_c, a1_c, a2_c)+""" : NOP()
Ro = Yt ? Rs."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , kernel , a1 , a2 )+""" : NOP()
Go = Ut ? Gs."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , kernel , a1 , a2 )+""" : NOP()
Bo = Vt ? Bs."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , kernel , a1 , a2 )+""" : NOP()

Ag = At && nr_wght_c > 0 ? As."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , "Gauss" , 100 )+""" : NOP()
Rg = Yt && nr_wght > 0 ? Rs."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , "Gauss" , 100 )+""" : NOP()
Gg = Ut && nr_wght > 0 ? Gs."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , "Gauss" , 100 )+""" : NOP()
Bg = Vt && nr_wght > 0 ? Bs."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , "Gauss" , 100 )+""" : NOP()

Ar = At && nr_wght_c > 0 ? Ao.Resize8_Repair(Ag, 1, -1) : NOP()
Rr = Yt && nr_wght > 0 ? Ro.Resize8_Repair(Rg, 1, -1) : NOP()
Gr = Ut && nr_wght > 0 ? Go.Resize8_Repair(Gg, 1, -1) : NOP()
Br = Vt && nr_wght > 0 ? Bo.Resize8_Repair(Bg, 1, -1) : NOP()

Am = At ? nr_wght_c == 1 ? Ar : nr_wght_c > 0 ? Ao.Merge(Ar, nr_wght_c) : Ao : NOP()
Rm = Yt ? nr_wght == 1 ? Rr : nr_wght > 0 ? Ro.Merge(Rr, nr_wght ) : Ro : Rs.BlankClip(width=ow , height=oh , color_yuv=$008080)
Gm = Ut ? nr_wght == 1 ? Gr : nr_wght > 0 ? Go.Merge(Gr, nr_wght ) : Go : Gs.BlankClip(width=ow , height=oh , color_yuv=$008080)
Bm = Vt ? nr_wght == 1 ? Br : nr_wght > 0 ? Bo.Merge(Br, nr_wght ) : Bo : Bs.BlankClip(width=ow , height=oh , color_yuv=$008080)

res = At ? MergeARGB(Am, Rm, Gm, Bm) : MergeRGB(Rm, Gm, Bm, sCSP)
""") : \
Eval("""
Ys = input.ConvertToY8()
Us = input.UtoY8()
Vs = input.VtoY8()

Yo = Yt ? Ys."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , kernel , a1 , a2 )+""" : NOP()
Uo = Ut ? Us."""+Resize8_resstr(owc, ohc, src_lc+chfix, src_tc+cvfix, src_wc, src_hc, kernel_c, a1_c, a2_c)+""" : NOP()
Vo = Vt ? Vs."""+Resize8_resstr(owc, ohc, src_lc+chfix, src_tc+cvfix, src_wc, src_hc, kernel_c, a1_c, a2_c)+""" : NOP()

Yg = Yt && nr_wght > 0 ? Ys."""+Resize8_resstr(ow , oh , src_l , src_t , src_w , src_h , "Gauss" , 100 )+""" : NOP()
Ug = Ut && nr_wght_c > 0 ? Us."""+Resize8_resstr(owc, ohc, src_lc+chfix, src_tc+cvfix, src_wc, src_hc, "Gauss" , 100 )+""" : NOP()
Vg = Vt && nr_wght_c > 0 ? Vs."""+Resize8_resstr(owc, ohc, src_lc+chfix, src_tc+cvfix, src_wc, src_hc, "Gauss" , 100 )+""" : NOP()

Yr = Yt && nr_wght > 0 ? Yo.Resize8_Repair(Yg, 1, -1) : NOP()
Ur = Ut && nr_wght_c > 0 ? Uo.Resize8_Repair(Ug, 1, -1) : NOP()
Vr = Vt && nr_wght_c > 0 ? Vo.Resize8_Repair(Vg, 1, -1) : NOP()

Ym = Yt ? nr_wght == 1 ? Yr : nr_wght > 0 ? Yo.Merge(Yr, nr_wght ) : Yo : Ys.BlankClip(width=ow , height=oh , color_yuv=$808080)
Um = Ut ? nr_wght_c == 1 ? Ur : nr_wght_c > 0 ? Uo.Merge(Ur, nr_wght_c) : Uo : Us.BlankClip(width=owc, height=ohc, color_yuv=$808080)
Vm = Vt ? nr_wght_c == 1 ? Vr : nr_wght_c > 0 ? Vo.Merge(Vr, nr_wght_c) : Vo : Vs.BlankClip(width=owc, height=ohc, color_yuv=$808080)

res = YtoUV(Um, Vm, Ym)
""")

return res
}

Function Resize8_resstr(int "ow", int "oh", float "src_l", float "src_t", float "src_w", float "src_h",
\ string "kernel", float "a1", float "a2")
{
ow = string(ow)
oh = string(oh)
src_l = string(src_l)
src_t = string(src_t)
src_w = string(src_w)
src_h = string(src_h)

resstr = kernel == "Catmull-Rom" ? "BicubicResize ("+ow+", "+oh+", 0.0 , 0.5 , "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Hermite" ? "BicubicResize ("+ow+", "+oh+", 0.0 , 0.0 , "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Mitchell-Netravali" ? "BicubicResize ("+ow+", "+oh+", 1/3. , 1/3. , "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Robidoux" ? "BicubicResize ("+ow+", "+oh+", 0.3782, 0.3109, "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Bicubic" ? "BicubicResize ("+ow+", "+oh+", "+string(Default(a1, 1/3.))+", "+string(Default(a2, 1/3.))+", "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "SoftCubic" ? "BicubicResize ("+ow+", "+oh+", "+string(Default(a1/100., 0.75))+", "+string(Default(1-a1/100., 0.25))+", "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "SoftCubic100" ? "BicubicResize ("+ow+", "+oh+", 1.0 , 0.0 , "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : LeftStr(kernel, 9) == "SoftCubic" ? "BicubicResize ("+ow+", "+oh+", "+RightStr(kernel, 2)+"/100., 1-"+RightStr(kernel, 2)+"/100., "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Bilinear" ? "BilinearResize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Blankman" ? "BlackmanResize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", "+string(int(Default(a1, 4)))+")"
\ : kernel == "Blankman2" ? "BlackmanResize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", 2)"
\ : kernel == "Blankman3" ? "BlackmanResize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", 3)"
\ : kernel == "Blankman4" ? "BlackmanResize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", 4)"
\ : kernel == "Gauss" ? "GaussResize ("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", "+string(int(Default(a1, 30)))+")"
\ : kernel == "Gaussian" ? "GaussResize ("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", "+string(int(Default(a1, 30)))+")"
\ : kernel == "Lanczos" ? "LanczosResize ("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", "+string(int(Default(a1, 3)))+")"
\ : kernel == "Lanczos2" ? "LanczosResize ("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", 2)"
\ : kernel == "Lanczos3" ? "LanczosResize ("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", 3)"
\ : kernel == "Lanczos4" ? "Lanczos4Resize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Point" ? "PointResize ("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Sinc" ? "SincResize ("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+", "+string(int(Default(a1, 4)))+")"
\ : kernel == "Spline16" ? "Spline16Resize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Spline36" ? "Spline36Resize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : kernel == "Spline64" ? "Spline64Resize("+ow+", "+oh+", "+src_l+", "+src_t+", "+src_w+", "+src_h+")"
\ : "Unknown Kernel"
Assert(resstr!="Unknown Kernel", """Resize8: Unsupported "kernel" or "kernel_c"!""")

return resstr
}

Function Resize8_Repair(clip input, clip source, int "mode", int "modeU", int "modeV")
{
try
{
return input.Repair(source, mode, modeU, modeV)
}
catch(error_msg)
{
return input.ConvertToYV12().Repair(source.ConvertToYV12(), mode, modeU, modeV).ConvertToY8()
}
}

Function Resize8_undef() {}

Function GetCSP(clip c)
{
return c.IsPlanar ? c.IsYV12 ? "YV12" :
\ c.IsYV16 ? "YV16" :
\ c.IsYV24 ? "YV24" : c.GetCSP_Y8_YV411() :
\ c.IsYUY2 ? "YUY2" :
\ c.IsRGB32 ? "RGB32" :
\ c.IsRGB24 ? "RGB24" : "Unknown"

Function GetCSP_Y8_YV411(clip c)
{
try
{
c.UtoY()
csp = "YV411"
}
catch ( error_msg )
{
csp = "Y8"
}

return csp
}
}
</pre></font>

Resize8 - Revision history

Reel.Deal: archived link

Reel.Deal: space

Reel.Deal: space

Reel.Deal: /* Examples */ corrections

Reel.Deal: almost done, a few things missing

Raffriff42: preliminary, copy of script /w no formatting