digitalFAQ.com Forums [Archives] - TMPGEnc: How to add copyright to my files?

Hey ren,

Here a Add logo script for avs:
You will need "Logo.vdf" and you can cut and paste
files from this post for Add_Logo.avs and VDub_Filters.avs.
VDub_Filters contains other functions so don't be put off by its size.

#------- Add Logo ------
LoadPlugin("E:\DVD Backup\2 - DVD2SVCD\MPEG2DEC\MPEG2DEC2.dll")
mpeg2source("D:\Temp\movie.d2v")
BicubicResize(640,352,0.333,0.333)
#TemporalSmoother(2,2)
AddBoarders(0,0,0,0)
#
# VituralDub Filters
#
# example1 (static logo):
# Import("E:\DVD Backup\2 - DVD2SVCD\VDub_Filters\VDub_Filters.avs") # See VDub_Filters Below
# ConvertToRGB()
# VD_logo(0,0,128,true,0,0,255,0,VirtualDub_plugin_d irectory+"\logo2.bmp",false,100,200,0,10,180,10)
# ConvertToYUY2()
#
# example2 (animated logo):
# Import("E:\DVD Backup\2 - DVD2SVCD\VDub_Filters\VDub_Filters.avs")
# ConvertToRGB()
# VD_Logo(33, 33, 128, true, 0, 0, 0, 0, "G:\Recu0001.bmp", true, 0, 1, 20, 0, 0, 0)
# ConvertToYUY2()
# ------ End of Add_Logo.avs

# ------ VDub_Filters.avs
################################################## ###########
# This file provides convenient Avisynth interfaces to #
# various VirtualDub plugins. Load it in your script with: #
# #
# Import("vdub_filters.avs") #
# #
# This file contains all the filters in the LabDV-package #
# plus some extra filters. #
# #
# Version 1.4, 06-26-2002; #
# sent remarks to w.j.dijkhof@tue.nl #
################################################## ###########

################################################## ######
# Change VirtualDub_plugin_directory below to point to #
# the directory containing your VirtualDub plugins. #
################################################## ######

global VirtualDub_plugin_directory = "c:\Program Files\virtualdub\plugins"

################################################## ################
# Some general notes: #
# #
# 1) Colorspace: #
# VD filters use RGB input as opposed to Avisynth which works #
# in both YUV and RGB space. Simply adding ConvertToRGB before #
# the VD_xxxx call and everything should work ok and add #
# ConvertToYUY2 after the VD_xxxx call. #
# #
# 2) Interlaced material: #
# Some VirtualDub filters (for example Zoom v1.2) have an option #
# to select interlaced while the corresponding script has not. #
# This can be done internally in AviSynth in the following way: #
# clip.SeparateFields.VD_Zoom(...).Weave or #
# Weave(VD_Zoom(SeparateFields(clip),...)) #
################################################## ################

####################################
# Most filters can be found at: #
# http://sauron.mordor.net/dgraft/ #
####################################

# The filters in the LabDV package:

#####################################
# 2D Cleaner by Jim Casaburi, v0.6b #
# #
# threshold (0-255), radius (0-10) #
# #
# For athlon/pIII/pIV users there #
# is an optimized version. #
#####################################

function VD_2DCleaner(clip clip, int "threshold", int "radius", bool "interlaced")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \2dclean.vdf", "_VD_2DCleaner")
return clip._VD_2DCleaner(default(interlaced,false)?1:0, default(threshold,75), default(radius,1))
}

# example:
# ConvertToRGB()
# VD_2DCleaner(75,1)
# ConvertToYUY2()

####################################
# Temporal Cleaner by Jim Casaburi #
####################################

function VD_TemporalCleaner(clip clip, int "threshold", int "pixel_lock", int "threshold2",
\ int "pixel_lock2", int "scene", bool "partial", bool "yuv")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \tclean.vdf", "_VD_TemporalCleaner", 10)
return clip._VD_TemporalCleaner(default(threshold,10), default(pixel_lock,4),
\ default(threshold2,16), default(pixel_lock2,8), default(scene,30),
\ default(partial,false)?1:0, default(yuv,true)?1:0)
}

# example:
# ConvertToRGB()
# VD_TemporalCleaner(10,4,16,8,30,false,true)
# ConvertToYUY2()

############################
# Colorize by Donald Graft #
############################

function VD_Colorize(clip clip, int "hue", int "sat", int "lum")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \colorize.vdf", "_VD_Colorize")
return clip._VD_Colorize(default(hue, 0), default(sat, 150), default(lum, 150))
}

############################################
# Hue/Saturation/Intensity by Donald Graft #
# #
# there is a version of this filter called #
# "Tweak11 by Donald Graft" which can be #
# used in Avisynth (directly in YUV-space) #
############################################

function DG_FloatToInt(f) { return round((default(f,1.0) - 1) * 100) }

function VD_Hue(clip clip, int "hue", bool "preserve_luma", float "sat", float "inten",
\ bool "r", bool "g", bool "b", bool "y", bool "c", bool "m")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \hue.vdf", "_VD_Hue")
hue = default(hue, 0)
sat = DG_FloatToInt(sat)
inten = DG_FloatToInt(inten)
flags = (default(r,true)?1:0)+(default(g,true)?2:0)+(defau lt(b,true)?4:0)
\ +(default(y,true)?8:0)+(default(c,true)?16:0)+(def ault(m,true)?32:0)
return clip._VD_Hue(hue, default(preserve_luma,false)?1:0, sat, inten, flags)
}

#############################################
# Red/Green/Blue Adjustment by Donald Graft #
#############################################

function VD_RGBAdjustment(clip clip, float "r", float "g", float "b")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \rgb.vdf", "_VD_RGBAdjustment")
return clip._VD_RGBAdjustment(DG_FloatToInt(r), DG_FloatToInt(g), DG_FloatToInt(b))
}

#############################
# Smart Bob by Donald Graft #
#############################

# NB: the input clip is run through SeparateFields. You may need to use
# AssumeFrameBased, AssumeFieldBased, or ComplementParity beforehand.

function VD_SmartBob(clip clip, bool "show_motion", int "threshold", bool "motion_map_denoising")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \bob.vdf", "_VD_SmartBob", 1)
return clip.SeparateFields._VD_SmartBob(clip.GetParity()? 1:0,
\ default(show_motion,false)?1:0, default(threshold,10),
\ default(motion_map_denoising,true)?1:0)
}

#############################################
# Smart Deinterlace by Donald Graft, v2.7b2 #
# #
# m(otion)_threshold (0-35 ?), #
# s(cene)_c(hange)_threshold (0-10), #
# mode = "frame", "field" or "both" #
# channel = "luma" or "all" #
# #
# For pII, pIII and pIV users there is an #
# optimized version called QS Deinterlace. #
#############################################

# NB: the "Advanced Processing" options (the last four arguments) duplicate built-in Avisynth functionality.

function VD_SmartDeinterlace(clip clip, string "mode", string "channel", bool "show_motion", bool "blend",
\ bool "cubic", bool "motion_map_denoising", int "m_threshold", int "sc_threshold",
\ bool "fs_before", bool "shift", bool "fs_after", bool "disable")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \smart.vdf", "_VD_SmartDeinterlace", 1)
mode = default(mode, "frame")
mode = (mode=="frame") ? 0 : (mode=="field") ? 1 : (mode=="both") ? 2 : -1
Assert(mode>=0, """VD_SmartDeinterlace: "mode" parameter must be "frame", "field", or "both"""")
channel = default(channel, "luma")
channel = (channel=="luma") ? 0 : (channel=="all") ? 1 : -1
Assert(channel>=0, """VD_SmartDeinterlace: "channel" parameter must be "luma" or "all"""")
return clip._VD_SmartDeinterlace(default(show_motion,fals e)?1:0, default(blend,false)?1:0,
\ default(m_threshold,15), default(sc_threshold,100), default(shift,false)?1:0,
\ default(fs_before,false)?1:0, default(fs_after,false)?1:0, default(disable,false)?1:0,
\ default(motion_map_denoising,false)?1:0, mode, channel, default(cubic,true)?1:0)
}

# example:
# ConvertToRGB()
# VD_SmartDeinterlace("frame","luma",false,true,fals e,false,15,100)
# ConvertToYUY2()

###########################################
# Smart Smoother by Donald Graft, v1.1 #
# #
# diameter (3-11, odd), threshold (1-200) #
###########################################

function VD_SmartSmoother(clip clip, int "diameter", int "threshold", bool "interlaced")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \smooth.vdf", "_VD_SmartSmoother")
return clip._VD_SmartSmoother(default(diameter,5), default(threshold,25),
\ default(interlaced,false)?1:0)
}

# example:
# ConvertToRGB()
# VD_SmartSmoother(5,25,false)
# ConvertToYUY2()

################################
# Unsharp Mask by Donald Graft #
################################

function VD_UnsharpMask(clip clip, int "diameter", int "strength", int "threshold",
\ bool "interlaced", int "mask_top", int "mask_bottom", int "mask_left", int "mask_right")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \unsharp.vdf", "_VD_UnsharpMask", 1)
return clip._VD_UnsharpMask(default(diameter,5), default(strength,32),
\ default(threshold,0), default(mask_left,0), default(mask_right,0),
\ default(mask_bottom,0), default(mask_top,0), default(interlaced,false)?1:0)
}

################################################## ########
# Subtitler by Avery Lee #
# #
# filename is the complete location of the subtitle file #
# with parentheses around it #
################################################## ########

# NB: non-antialiased mode is not supported, because
# the VD emulation doesn't support NEEDS_HDC

function VD_Subtitler(clip clip, string filename)
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \subtitler.vdf", "_VD_Subtitler")
return clip._VD_Subtitler(1, filename)
}

# example: ConvertToRGB()
# VD_Subtitler("c:\_project\subs.ssa")
# ConvertToYUY2()

#################################
# Border Smear by Simon Walters #
#################################

function VD_BorderSmear(clip clip, int yt, int yb)
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \brdrsmr.vdf", "_VD_BorderSmear")
return clip._VD_BorderSmear(yt, yb)
}

##########################
# Cartoon Tool by flaXen #
##########################

# NB: "Show Inverse Map" not supported since it apparently
# is not accessible through the scripting interface

function VD_CartoonTool(clip clip, int "scale_base", int "scale_intensity", int "pixel_base")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \fxtoon.vdf", "_VD_CartoonTool")
return clip._VD_CartoonTool(default(scale_base,16),defaul t(scale_intensity,200),default(pixel_base,16))
}

########################
# VHS Filter by flaXen #
########################

function VD_VHS(clip clip, bool "stabilize", int "luma_threshold", int "chroma_threshold",
\ int "temporal_error", int "temporal_bias", int "noise_threshold",
\ int "pixel_radius", bool "prefilter", bool "postfilter", bool "sharpen",
\ int "sharpen_amount", bool "eight_direction", int "chroma_shift_x",
\ int "chroma_shift_y", bool "shift_i", bool "shift_q")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \fxvhs.vdf", "_VD_VHS")
return clip._VD_VHS(default(stabilize,true)?1:0, default(luma_threshold,5),
\ default(chroma_threshold,30), default(temporal_error,15), default(temporal_bias,5),
\ default(noise_threshold,10), default(pixel_radius,1), default(prefilter,false)?1:0,
\ default(postfilter,false)?1:0, default(sharpen,false)?1:0, default(sharpen_amount,15),
\ default(eight_direction,false)?1:0, default(chroma_shift_x,-1), default(chroma_shift_y,0),
\ default(shift_i,false)?1:0, default(shift_q,false)?1:0)
}

# filters from internet:

#################################################
# 2D Cleaner optimized by Jaan Kalda, v0.9 #
# (optimized version of 2D Cleaner, for the #
# athlon users) #
# #
# Threshold (0-255), Radii around source pixel: #
# the values must satisfy #
# x and y >= 0 and (2x+1)(2y+1)<=121. #
# Either value, but not both may be 0. #
#################################################

function VD_2DCleaneroptk7(clip clip, int "threshold", int "radiusx", int "radiusy", bool "interlaced")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \2dcleanopt_k7.vdf", "_VD_2DCleaneroptk7")
return clip._VD_2DCleaneroptk7(default(interlaced,false)? 1:0, default(threshold,10), default(radiusx,2),
\ default(radiusy,2))
}

# example: ConvertToRGB()
# VD_2DCleaneroptk7(75,1,1)
# ConvertToYUY2()

#################################################
# 2D Cleaner optimized by Jaan Kalda, v0.9 #
# (optimized version of 2D Cleaner, for the #
# pIII or pIV users) #
# #
# Threshold (0-255), Radii around source pixel: #
# the values must satisfy #
# x and y >= 0 and (2x+1)(2y+1)<=121. #
# Either value, but not both may be 0. #
#################################################

function VD_2DCleaneroptp3(clip clip, int "threshold", int "radiusx", int "radiusy", bool "interlaced")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \2dcleanopt_p3.vdf", "_VD_2DCleaneroptp3")
return clip._VD_2DCleaneroptp3(default(interlaced,false)? 1:0, default(threshold,10), default(radiusx,2),
\ default(radiusy,2))
}

# example: ConvertToRGB()
# VD_2DCleaneroptp3(10,2,2)
# ConvertToYUY2()

#######################################
# Xsharpen by Donald Graft, v1.0b2 #
# #
# Strength (0-255), Threshold (0-255) #
#######################################

function VD_Xsharpen(clip clip, int "strength", int "threshold")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \xsharpen.vdf", "_VD_Xsharpen")
return clip._VD_Xsharpen(threshold, strength)
}

# example: ConvertToRGB()
# VD_Xsharpen(10,128)
# ConvertToYUY2()

#################################################
# WarpSharp by Avery Lee and Donald Graft, v1.1 #
# #
# depth (0-400) #
# #
# make sure that you got a version of #
# WarpSharp that works in Avisynth, see: #
# http://home.attbi.com/~neuron2/warpsharp.zip #
#################################################

function VD_WarpSharp(clip clip, int "depth")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \warpsharp.vdf", "_VD_WarpSharp")
return clip._VD_WarpSharp(depth)
}

# example: ConvertToRGB()
# VD_WarpSharp(50)
# ConvertToYUY2()

################################################## ########
# Dynamic noise reduction by Steven Don and Donald Graft #
# (has no version number) #
# #
# threshold (0-31) #
# #
# make sure that you got a version of #
# WarpSharp that works in Avisynth, see: #
# http://home.attbi.com/~neuron2/warpsharp.zip #
################################################## ########

function VD_Dnr(clip clip, int "threshold")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \dnr.vdf", "_VD_Dnr")
return clip._VD_Dnr(threshold)
}

# example: ConvertToRGB()
# VD_Dnr(25)
# ConvertToYUY2()

##########################################
# SmartResize by Donald Graft, v1.1 #
# #
# colors: green $00ff00 #
# red $ff0000 #
# blue $0000ff (or 255) #
# black $000000 (or 0) #
# (for other colors, look in the filter #
# in Virtual Dub itself) #
# #
# mode = "neighbour", "bilinear", #
# "bicubic", "p_bilinear" or "p_bicubic" #
# #
# The calculator isn't included in #
# the script, if you want to use it #
# I suggest to open your avi/avs in #
# Virtual Dub and use the calculator #
# to determine how to resize. #
##########################################

function VD_SmartResize(clip clip, int "new_width", int "new_height", bool "interlaced", bool "letterbox",
\ int "frame_width", int "frame_height", string "mode", int "color", string "calculator")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \Resize.vdf", "_VD_SmartResize")
mode = default(mode, "p_bicubic")
interlaced = default(interlaced, false)
mode = (mode=="neighbour" && interlaced==false) ? 0 : (mode=="bilinear" && interlaced==false) ? 1 : (mode=="bicubic" && interlaced==false) ? 2 :
\ (mode=="p_bilinear" && interlaced==false) ? 3 : (mode=="p_bicubic" && interlaced==false) ? 4 : (mode=="neighbour" && interlaced==true) ? 128 :
\ (mode=="bilinear" && interlaced==true) ? 129 : (mode=="bicubic" && interlaced==true) ? 130 : (mode=="p_bilinear" && interlaced==true) ? 131 :
\ (mode=="p_bicubic" && interlaced==true) ? 132 : -1
Assert(mode>=0, """VD_SmartResize: "mode" parameter must be "neighbour", "bilinear", "bicubic", "p_bilinear", "p_bicubic"""")
return clip._VD_SmartResize(new_width, new_height, default(letterbox,false)?1:0, mode, default(frame_width,new_width),
\ default(frame_height,new_height), default(color,0), default(calculator,""))
}

# example1:
# ConvertToRGB()
# VD_SmartResize(320,240,false,true,320,320)
# ConvertToYUY2()

# example2:
# ConvertToRGB()
# VD_SmartResize(320,240,false,true,320,320,"p_bicub ic",$ff0000)
# ConvertToYUY2()

# new filters:

################################################## ##################
# QS Deinterlace by Pavel Kuznetsov, v0.52b (optimized version of #
# Smart Deinterlace, for the pentium II users) #
# #
# mode = "frame", "field" or "both" #
# channel = "luma" or "all" #
# #
# http://freetime.sinor.ru/observatory...?qsdeinterlace #
# Please use http://babelfish.altavista.com for translation. #
################################################## ##################

function VD_QSdeinterlaceII(clip clip, string "mode", string "channel", bool "show_motion", bool "blend",
\ bool "cubic", bool "motion_map_denoising", int "m_threshold", int "sc_threshold",
\ bool "fs_before", bool "shift", bool "fs_after", bool "disable")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \QSdeinterlacePII.vdf", "_VD_QSdeinterlaceII", 1)
mode = default(mode, "frame")
mode = (mode=="frame") ? 0 : (mode=="field") ? 1 : (mode=="both") ? 2 : -1
Assert(mode>=0, """VD_QSdeinterlaceIII: "mode" parameter must be "frame", "field", or "both"""")
channel = default(channel, "luma")
channel = (channel=="luma") ? 0 : (channel=="all") ? 1 : -1
Assert(channel>=0, """VD_QSdeinterlaceII: "channel" parameter must be "luma" or "all"""")
return clip._VD_QSdeinterlaceII(default(show_motion,false )?1:0, default(blend,false)?1:0,
\ default(m_threshold,15), default(sc_threshold,100), default(shift,false)?1:0,
\ default(fs_before,false)?1:0, default(fs_after,false)?1:0, default(disable,false)?1:0,
\ default(motion_map_denoising,false)?1:0, mode, channel, default(cubic,true)?1:0)
}

# example VD_QSdeinterlaceII("frame","luma",false,true,false ,false,15,100)

################################################## ############################
# QS Deinterlace by Pavel Kuznetsov, v0.50b and v0.52b (optimized version of #
# Smart Deinterlace, for the pentium III users) #
# #
# mode = "frame", "field" or "both" #
# channel = "luma" or "all" #
# #
# http://freetime.sinor.ru/observatory...?qsdeinterlace #
# Please use http://babelfish.altavista.com for translation. #
################################################## ############################

function VD_QSdeinterlaceIII(clip clip, string "mode", string "channel", bool "show_motion", bool "blend",
\ bool "cubic", bool "motion_map_denoising", int "m_threshold", int "sc_threshold",
\ bool "fs_before", bool "shift", bool "fs_after", bool "disable")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \QSdeinterlacePIII.vdf", "_VD_QSdeinterlaceIII", 1)
mode = default(mode, "frame")
mode = (mode=="frame") ? 0 : (mode=="field") ? 1 : (mode=="both") ? 2 : -1
Assert(mode>=0, """VD_QSdeinterlaceIII: "mode" parameter must be "frame", "field", or "both"""")
channel = default(channel, "luma")
channel = (channel=="luma") ? 0 : (channel=="all") ? 1 : -1
Assert(channel>=0, """VD_QSdeinterlaceIII: "channel" parameter must be "luma" or "all"""")
return clip._VD_QSdeinterlaceIII(default(show_motion,fals e)?1:0, default(blend,false)?1:0,
\ default(m_threshold,15), default(sc_threshold,100), default(shift,false)?1:0,
\ default(fs_before,false)?1:0, default(fs_after,false)?1:0, default(disable,false)?1:0,
\ default(motion_map_denoising,false)?1:0, mode, channel, default(cubic,true)?1:0)
}

# example VD_QSdeinterlaceIII("frame","luma",false,true,fals e,false,15,100)

################################################## ############################
# QS Deinterlace by Pavel Kuznetsov, v0.50b and v0.52b (optimized version of #
# Smart Deinterlace, for the pentium IV users) #
# #
# mode = "frame", "field" or "both" #
# channel = "luma" or "all" #
# #
# http://freetime.sinor.ru/observatory...?qsdeinterlace #
# Please use http://babelfish.altavista.com for translation. #
################################################## ############################

function VD_QSdeinterlaceIV(clip clip, string "mode", string "channel", bool "show_motion", bool "blend",
\ bool "cubic", bool "motion_map_denoising", int "m_threshold", int "sc_threshold",
\ bool "fs_before", bool "shift", bool "fs_after", bool "disable")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \QSdeinterlacePIV.vdf", "_VD_QSdeinterlaceIV", 1)
mode = default(mode, "frame")
mode = (mode=="frame") ? 0 : (mode=="field") ? 1 : (mode=="both") ? 2 : -1
Assert(mode>=0, """VD_QSdeinterlaceIV: "mode" parameter must be "frame", "field", or "both"""")
channel = default(channel, "luma")
channel = (channel=="luma") ? 0 : (channel=="all") ? 1 : -1
Assert(channel>=0, """VD_QSdeinterlaceIV: "channel" parameter must be "luma" or "all"""")
return clip._VD_QSdeinterlaceIV(default(show_motion,false )?1:0, default(blend,false)?1:0,
\ default(m_threshold,15), default(sc_threshold,100), default(shift,false)?1:0,
\ default(fs_before,false)?1:0, default(fs_after,false)?1:0, default(disable,false)?1:0,
\ default(motion_map_denoising,false)?1:0, mode, channel, default(cubic,true)?1:0)
}

# example VD_QSdeinterlaceIV("frame","luma",false,true,false ,false,15,100)

##############################################
# Zoom by Donald Graft and Avery Lee, v1.2 #
# #
# mode = "neighbour", "bilinear", "bicubic", #
# "p_bilinear" or "p_bicubic". #
# #
# See "simplified_versions.avs" for some #
# examples. #
##############################################

function VD_Zoom(clip clip, int "width", int "height", int "focusX", int "focusY",
\ int "start_per", int "end_per", int "start_Frame", int "end_frame",
\ int "red", int "green", int "blue", string "mode", int "start2_per",
\ int "end2_per", int "start2_frame", int "end2_frame")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \Zoom.vdf", "_VD_Zoom")
mode = default(mode, "p_bicubic")
mode = (mode=="neighbour") ? 0 : (mode=="bilinear") ? 1 : (mode=="bicubic") ? 2 :
\ (mode=="p_bilinear") ? 3 : (mode=="p_bicubic") ? 4 : -1
Assert(mode>=0, """VD_Zoom: "mode" parameter must be "neighbour", "bilinear", "bicubic", "p_bilinear", "p_bicubic"""")
return clip._VD_Zoom(default(width,320), default(height,240),
\ default(focusX,160), default(focusY,120), default(start_per,100), default(end_per,500),
\ default(start_frame,0), default(end_frame,500), default(start2_per,0), default(end2_per,0),
\ default(start2_frame,0), default(end2_frame,0), default(red,0), default(green,140), default(blue,180), mode)
}

# example (clip of 300 frames):
# ConvertToRGB()
# VD_Zoom(512,384,256,80,100,300,134,144,0,0,0,"p_bi cubic",300,100,144,154)
# ConvertToYUY2()

################################################## ################################################## ###################
# LogoAway by Krzysztof Wojdon, v3.5fix1 #
# #
# Load your avs in VirtualDub without this script. Select "shape XY" (or "shape UGLARM"), select "visible borders" #
# and press preview. Enter and adjust "logo border position" and "logo border size" by looking at the preview. After #
# adjusting close preview and press twice "ok". Move the slider to a suitable frame and copy the output frame to the #
# clipboard (under "video", or by pressing ctrl+2). Open the picture on the clipboard in paintshop, corel photo-paint #
# or adobe photo-shop and make the alpha mask file by following the help file of the Logoaway filter (called #
# "alpha.bmp" in the examples below. #
# #
# When I wrote this script I couldn't find documentation about the "Shape/Lightmap bitmap" option, called "filename2" #
# in the script. If anyone knows, please mail me. #
# #
# mode: off, luminance, XY, uglarm, shape_XY, shape_uglarm or solid #
# color: see script of SmartResize v1.1 #
# upper_left, upper_right, down_right or down_left: "NW", "NE", "SW" or "SE" #
# border_up, border_right, border_down or border_left: "direct", "opposite", or "interpolate" #
################################################## ################################################## ###################

function VD_LogoAway(clip clip, string "mode", int "border_X", int "border_Y", int "logosize_X", int "logosize_Y", bool "alpha",
\ bool "visible_border", string "filename1", int "keyframe", int "color", int "XY_weight", int "blur", string "upper_left",
\ string "upper_right", string "down_right", string "down_left", string "border_up", string "border_right", string "border_down",
\ string "border_left", string "filename2")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \logoaway.vdf", "_VD_LogoAway")
mode = default(mode, "XY")
mode = (mode=="off") ? 0 : (mode=="luminance") ? 1 : (mode=="XY") ? 2 :
\ (mode=="uglarm") ? 3 : (mode=="shape_XY") ? 4 : (mode=="shape_uglarm") ? 5 : (mode=="solid") ? 6 : -1
Assert(mode>=0, """VD_LogoAway: "mode" parameter must be "off", "luminance", "XY", "uglarm", "shape_XY", "shape_uglarm", "solid"""")
border_X = default(border_X,560)
border_Y = default(border_Y,35)
A = border_X*65536+border_Y
logosize_X = default(logosize_X,100)
logosize_Y = default(logosize_Y,75)
B = logosize_X*65536+logosize_Y
mode2 = (alpha==false && visible_border==false) ? 0 : (alpha==false && visible_border==true) ? 1 :
\ (alpha==true && visible_border==false) ? 2 : (alpha==true && visible_border==true) ? 3 : -1
upper_left = default(upper_left, "NW")
upper_left = (upper_left=="NW") ? 0 : (upper_left=="NE") ? 1 : (upper_left=="SW") ? 2 : (upper_left=="SE") ? 3 : -1
upper_right = default(upper_right, "NE")
upper_right = (upper_right=="NW") ? 0 : (upper_right=="NE") ? 1 : (upper_right=="SW") ? 2 : (upper_right=="SE") ? 3 : -1
down_right = default(down_right, "SE")
down_right = (down_right=="NW") ? 0 : (down_right=="NE") ? 1 : (down_right=="SW") ? 2 : (down_right=="SE") ? 3 : -1
down_left = default(down_left, "SW")
down_left = (down_left=="NW") ? 0 : (down_left=="NE") ? 1 : (down_left=="SW") ? 2 : (down_left=="SE") ? 3 : -1
Assert(upper_left>=0, """VD_LogoAway: "upper_left" parameter must be "NW", "NE", "SE", "SW"""")
Assert(upper_right>=0, """VD_LogoAway: "upper_right" parameter must be "NW", "NE", "SE", "SW"""")
Assert(down_right>=0, """VD_LogoAway: "down_right" parameter must be "NW", "NE", "SE", "SW"""")
Assert(down_left>=0, """VD_LogoAway: "down_left" parameter must be "NW", "NE", "SE", "SW"""")
border_up = default(border_up, "direct")
border_up = (border_up=="direct") ? 0 : (border_up=="opposite") ? 1 : (border_up=="interpolate") ? 2 : -1
border_right = default(border_right, "direct")
border_right = (border_right=="direct") ? 0 : (border_right=="opposite") ? 1 : (border_right=="interpolate") ? 2 : -1
border_down = default(border_down, "direct")
border_down = (border_down=="direct") ? 0 : (border_down=="opposite") ? 1 : (border_down=="interpolate") ? 2 : -1
border_left = default(border_left, "direct")
border_left = (border_left=="direct") ? 0 : (border_left=="opposite") ? 1 : (border_left=="interpolate") ? 2 : -1
Assert(border_up>=0, """VD_LogoAway: "border_up" parameter must be "direct", "opposite", "interpolate"""")
Assert(border_right>=0, """VD_LogoAway: "border_right" parameter must be "direct", "opposite", "interpolate"""")
Assert(border_down>=0, """VD_LogoAway: "border_down" parameter must be "direct", "opposite", "interpolate"""")
Assert(border_left>=0, """VD_LogoAway: "border_left" parameter must be "direct", "opposite", "interpolate"""")
t = 1*down_right + 256*down_left + 65536*upper_right + 16777216*upper_left
v = 1*border_left + 256*border_down + 65536*border_right + 16777216*border_up
return clip._VD_LogoAway(mode, A, B, default(keyframe,1), default(color,0), default(XY_Weight,5), mode2, t, v,
\ default(blur,1), default(filename1,"g:\alpha.bmp"), default(filename2,""))
}

# examples:
# ConvertToRGB()
# VD_LogoAway("XY",560,35,100,75,true,false,"g:\alph a.bmp",1,0,5,1)
# VD_LogoAway("XY",560,35,100,75,true,false,"g:\alph a.bmp",1,0,5,1,"NW","NE","SE","SW","direct","direc t","direct","direct")
# ConvertToYUY2()

################################################## #################
# Logo by Donald Graft, v1.3b4 #
# #
# In the filter configuration dialog box, enter the input file. #
# If the specified bitmap file cannot be found, or if it is not #
# a bitmap file, or if it is of the wrong depth (depth must be 24 #
# bit), the output frame will be all black. #
# #
# See "simplified_versions.avs" for some examples. #
################################################## #################

function VD_Logo(clip clip, int "x", int "y", int "alpha", bool "transparent",
\ int "xr", int "xg", int "xb", int "tolerance", string "filename",
\ bool "animate", int "start", int "duration", int "loops",
\ int "fadeinlen", int "fadeoutend", int "fadeoutlen")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \logo.vdf", "_VD_Logo", 1)
return clip._VD_Logo(default(x,0), default(y,0), default(alpha,128),
\ default(transparent,true)?1:0, default(xr,0), default(xg,0), default(xb,255),
\ default(tolerance,0), default(filename,VirtualDub_plugin_directory+"\log o.bmp"),
\ default(animate,false)?1:0, default(start,0), default(duration,0), default(loops,0),
\ default(fadeinlen,0), default(fadeoutend,200), default(fadeoutlen,0))
}

# example1 (static logo):
# ConvertToRGB()
# VD_logo(0,0,128,true,0,0,255,0,VirtualDub_plugin_d irectory+"\logo2.bmp",false,100,200,0,10,180,10)
# ConvertToYUY2()

# example2 (animated logo):
# ConvertToRGB()
# VD_Logo(33, 33, 128, true, 0, 0, 0, 0, "G:\Recu0001.bmp", true, 0, 1, 20, 0, 0, 0)
# ConvertToYUY2()

###########################################
# Smart Smoother HiQ by Klaus Post, v2.11 #
# #
# On Donald Grafts homepage there is a #
# link to a version of Smoother HiQ (also #
# made by Klaus) that works directly in #
# YUV-space. #
# #
# diameter (3-13, odd), #
# threshold (1-200), amount (1-254) #
# mode = "average" or "weighted" #
###########################################

function VD_SmartSmoothHiQ(clip clip, int "diameter", int "threshold", int "amount", string "mode",
\ bool "weighted_difference", int "maintain_diffweight", bool "visualize_blur", bool "grayscale")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \SmoothHiQ.vdf", "_VD_SmartSmoothHiQ")
mode = default(mode, "weighted")
mode = (mode=="average") ? 0 : (mode=="weighted") ? 1 : -1
Assert(mode>=0, """VD_SmartSmoothHiQ: "mode" parameter must be "average" or "weighted"""")
return clip._VD_SmartSmoothHiQ(default(diameter,5), default(threshold,50), default(visualize_blur,false)?1:0, default(amount,254),
\ mode, default(grayscale,false)?1:0, default(weighted_difference,true)?1:0, default(maintain_diffweight,0))
}

# example:
# ConvertToRGB()
# VD_SmartSmoothHiQ(5,50,254,"weighted")
# ConvertToYUY2()

###########################################
# Smart Smoother IQ by Tim Park, v0.5 #
# #
# diameter (3-11, odd), threshold (1-200) #
# #
# For some reason the results in VDub and #
# AviSynth are very different. The latter #
# is blurred a lot more. #
###########################################

function VD_SmartSmoothIQ(clip clip, int "diameter", int "threshold", bool "interlaced")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \smooth.vdf", "_VD_SmartSmoothIQ")
return clip._VD_SmartSmoothIQ(default(diameter,5), default(threshold,25),
\ default(interlaced,false)?1:0)
}

# example:
# ConvertToRGB()
# VD_SmartSmoothIQ(5,25,false)
# ConvertToYUY2()

##############################################
# DeinterlaceAreaBased by Gunar Thalin, v1.3 #
# #
# mode = "interpolate" or "blend" #
# threshold (), edge_detect () #
# interlaced_area (0-100) #
##############################################

function VD_AreaBasedDeinterlace(clip clip, bool "deinterlaced_only", string "mode", int "threshold",
\ int "edge_detect", bool "log_frames", int "interlaced_area")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \DeinterlaceAreaBased.vdf", "_VD_DeinterlaceAreaBased")
mode = default(mode, "blend")
mode = (mode=="interpolate") ? 0 : (mode=="blend") ? 1 : -1
Assert(mode>=0, """VD_DeinterlaceAreaBased: "mode" parameter must be "interpolate" or "blend"""")
return clip._VD_DeinterlaceAreaBased(default(deinterlaced _only,false)?1:0, mode, default(threshold,27),
\ default(edge_detect,25), default(log_frames,false)?1:0, default("interlaced_area","0"))
}

# example:
# ConvertToRGB()
# VD_AreaBasedDeinterlace(false, "blend", 27, 25, false, 0)
# ConvertToYUY2()

################################################## ######################
# DeLogo by Karel Suhajda, v1.2.1 #
# #
# If the logo is (partially) located in the black bars you might want #
# to consider the filter LogoAway by Krzysztof Wojdon. #
# #
# Before this script can be used we need to do some preprocessing #
# in Virtual Dub to obtain the following pictures: #
# filename2 = photo_deblend.bmp #
# filename3 = photo_alpha.bmp #
# filename4 = photo_color.bmp #
# filename5 = photo_repair.bmp #
# #
# 1) Open the avi in Virtual Dub and select a frame where the logo #
# is clearly visible. Set video and audio on direct stream copy #
# and select a range of 100 frames in which the logo is contained. #
# Make a new avi of this and open it in Virtual Dub. #
# #
# 2) Select the frame of (1) and copy it to the clipboard. Open #
# your favourite graphics program and load the frame from the #
# clipboard. Paint an rectangle in which the logo fits "easily" #
# located red (255,0,0), the rest of the frame blue (0,0,255) leaving #
# a small stroke unpainted between the red and blue part. Save this #
# picture as a 24 RGB BMP file, say photo.bmp. #
# #
# 3) Return to the unclosed Virtual Dub and load the filter. #
# Press "load" next to "Analyse" in "Mask properties" and load #
# the BMP file. Fill in the "repair properties". Press "Show preview", #
# "Sample video" and "all frames". Finally make the desired files: #
# filename2 = photo_deblend.bmp #
# filename3 = photo_alpha.bmp #
# filename4 = photo_color.bmp #
# filename5 = photo_repair.bmp #
# by using the "Save as" button corresponding to deblend, alpha, #
# color and repair. #
# #
# range = "100-200, 300-400"; or whole clip range = "" #
# pixel aspect ratio: par_X (1-16), par_Y (1-16) #
# depth (1.0 - 8.0), power (0.0 - 16.0) #
################################################## ######################

function VD_DeLogo(clip clip, bool "on_frames", string "range", string "file_deblend", string "file_alpha",
\ string "file_color", string "file_repair", float "depth", float "power", int "par_X", int "par_Y", bool "interlaced")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \delogo.vdf", "_VD_DeLogo")
X = round(10*depth)
Y = round(10*power)
# theoretically: z = 100*log10(par_X/par_Y), as approximation I took a minimax-approximation (calculated with Maple):
v = - 48.96556825 + 63.18825967*par_X - 16.00966389*par_X*par_X + 2.473556539*par_X*par_X*par_X - .2133268695*par_X*par_X*par_X*par_X
\ + .009456579673*par_X*par_X*par_X*par_X*par_X - .0001675297934*par_X*par_X*par_X*par_X*par_X*par_X
w = - 48.96556825 + 63.18825967*par_X - 16.00966389*par_X*par_X + 2.473556539*par_X*par_X*par_X - .2133268695*par_X*par_X*par_X*par_X
\ + .009456579673*par_X*par_X*par_X*par_X*par_X - .0001675297934*par_X*par_X*par_X*par_X*par_X*par_X
z = round(v) - round(w)
return clip._VD_DeLogo(default(on_frames,false)?1:0, default(range,""), default(file_deblend,""), default(file_alpha,""),
\ default(file_color,""), default(file_repair,""), default(X,15), default(Y,40), default(interlaced,false)?1:0, z)
}

# example1:
# ConvertToRGB()
# VD_DeLogo(false, "", "F:\photo_deblend.bmp", "F:\photo_alpha.bmp", "F:\photo_color.bmp", "F:\photo_repair.bmp", 1.5, 4.0, 1, 1, false)
# ConvertToYUY2()

# example2:
# ConvertToRGB()
# VD_DeLogo(true, "100-200, 300-400", "F:\photo_deblend.bmp", "F:\photo_alpha.bmp", "F:\photo_color.bmp", "F:\photo_repair.bmp")
# ConvertToYUY2()

################################################
# GeneralConvolution3D v1.1, by Gunnar Thalin #
# #
# The last matrix (matrix for frame prior to #
# previous) has to be inserted manually (only #
# when one of its arguments is non-zero) #
# since a function can have 60 arguments at #
# maximum. #
# #
# 1) matrix entries: (0-256) #
# #
# 2) matrix for current frame: a11-a55 #
# #
# 3) matrix for previous frame: b11-b55 #
# #
# 4) The matrix entries have to be inserted in #
# hexadecimal notation. Thus for example: #
# 51 decimal = 3*16^1 + 3*16^0 hexadecimal = #
# = 33 hexadecimal. #
# #
# 5) a33 = 256 decimal = 1*16^2 hexadecimal #
# = 100 hexadecimal leaves the clip unchanged. #
# #
# 6) The matrix entries must be a three digit #
# number, insert zeros from the left when #
# necessary. #
################################################

function VD_GeneralConvolution3D(clip clip, string "mode", string "a11", string "a12", string "a13", string "a14",
\ string "a15", string "a21", string "a22", string "a23", string "a24", string "a25", string "a31", string "a32",
\ string "a33", string "a34", string "a35", string "a41", string "a42", string "a43", string "a44", string "a45",
\ string "a51", string "a52", string "a53", string "a54", string "a55", string "b11", string "b12", string "b13",
\ string "b14", string "b15", string "b21", string "b22", string "b23", string "b24", string "b25", string "b31",
\ string "b32", string "b33", string "b34", string "b35", string "b41", string "b42", string "b43", string "b44",
\ string "b45", string "b51", string "b52", string "b53", string "b54", string "b55")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \GeneralConvolution3D.vdf", "_VD_GeneralConvolution3D", 1)
mode = default(mode, "input")
mode = (mode=="input") ? 0 : (mode=="output") ? 1 : -1
Assert(mode>=0, """VD_GeneralConvolution3D: "mode" parameter must be "input" or "output"""")
a11 = default(a11, "000")
a12 = default(a12, "000")
a13 = default(a13, "000")
a14 = default(a14, "000")
a15 = default(a15, "000")
a21 = default(a21, "000")
a22 = default(a22, "000")
a23 = default(a23, "000")
a24 = default(a24, "000")
a25 = default(a25, "000")
a31 = default(a31, "000")
a32 = default(a32, "000")
a33 = default(a33, "046")
a34 = default(a34, "000")
a35 = default(a35, "000")
a41 = default(a41, "000")
a42 = default(a42, "000")
a43 = default(a43, "000")
a44 = default(a44, "000")
a45 = default(a45, "000")
a51 = default(a51, "000")
a52 = default(a52, "000")
a53 = default(a53, "000")
a54 = default(a54, "000")
a55 = default(a55, "000")
b11 = default(b11, "000")
b12 = default(b12, "000")
b13 = default(b13, "000")
b14 = default(b14, "000")
b15 = default(b15, "000")
b21 = default(b21, "000")
b22 = default(b22, "000")
b23 = default(b23, "000")
b24 = default(b24, "000")
b25 = default(b25, "000")
b31 = default(b31, "000")
b32 = default(b32, "000")
b33 = default(b33, "000")
b34 = default(b34, "000")
b35 = default(b35, "000")
b41 = default(b41, "000")
b42 = default(b42, "000")
b43 = default(b43, "000")
b44 = default(b44, "000")
b45 = default(b45, "000")
b51 = default(b51, "000")
b52 = default(b52, "000")
b53 = default(b53, "000")
b54 = default(b54, "000")
b55 = default(b55, "000")
# "matrix for frame prior to previous" elements:
c11 = "000"
c12 = "000"
c13 = "000"
c14 = "000"
c15 = "000"
c21 = "000"
c22 = "000"
c23 = "000"
c24 = "000"
c25 = "000"
c31 = "000"
c32 = "000"
c33 = "000"
c34 = "000"
c35 = "000"
c41 = "000"
c42 = "000"
c43 = "000"
c44 = "000"
c45 = "000"
c51 = "000"
c52 = "000"
c53 = "000"
c54 = "000"
c55 = "000"
str = "8"+a11+"8"+b11+"8"+c11 + "8"+a12+"8"+b12+"8"+c12 + "8"+a13+"8"+b13+"8"+c13 + "8"+a14+"8"+b14+"8"+c14 +
\ "8"+a15+"8"+b15+"8"+c15 + "8"+a21+"8"+b21+"8"+c21 + "8"+a22+"8"+b22+"8"+c22 + "8"+a23+"8"+b23+"8"+c23 +
\ "8"+a24+"8"+b24+"8"+c24 + "8"+a25+"8"+b25+"8"+c25 + "8"+a31+"8"+b31+"8"+c31 + "8"+a32+"8"+b32+"8"+c32 +
\ "8"+a33+"8"+b33+"8"+c33 + "8"+a34+"8"+b34+"8"+c34 + "8"+a35+"8"+b35+"8"+c35 + "8"+a41+"8"+b41+"8"+c41 +
\ "8"+a42+"8"+b42+"8"+c42 + "8"+a43+"8"+b43+"8"+c43 + "8"+a44+"8"+b44+"8"+c44 + "8"+a45+"8"+b45+"8"+c45 +
\ "8"+a51+"8"+b51+"8"+c51 + "8"+a52+"8"+b52+"8"+c52 + "8"+a53+"8"+b53+"8"+c53 + "8"+a54+"8"+b54+"8"+c54 +
\ "8"+a55+"8"+b55+"8"+c55
return clip._VD_GeneralConvolution3D(0, mode, str)
}

# example:
# ConvertToRGB()
# VD_GeneralConvolution3D("output","000","000","000" ,"000","000",
# \ "000","000","033","000","000",
# \ "000","033","034","033","000",
# \ "000","000","033","000","000",
# \ "000","000","000","000","000")
# ConvertToYUY2()

############################################
# DeinterlaceSmooth by Gunnar Thalin, v1.0 #
# #
# mode = "interpolate" or "blend" #
# threshold (), edge_detect () #
# interlaced_area (0-100) #
############################################

function VD_DeinterlaceSmooth(clip clip, bool "deinterlaced_only", string "mode", bool "alternate_field_order",
\ int "threshold", int "edge_detect", bool "log_frames", int "interlaced_area")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \deinterlacesmooth.vdf", "_VD_DeinterlaceSmooth")
mode = default(mode, "interpolate")
mode = (mode=="interpolate") ? 0 : (mode=="blend") ? 1 : -1
Assert(mode>=0, """VD_DeinterlaceSmooth: "mode" parameter must be "interpolate" or "blend"""")
return clip._VD_DeinterlaceSmooth(default(deinterlaced_on ly,false)?1:0, mode,
\ default(alternate_field_order,false)?1:0, default(threshold,24), default(edge_detect,20),
\ default(log_frames,false)?1:0, default("interlaced_area","0"))
}

# example (video is converted to 50/60 frames a second before applying the filter by using SeparateFields):
# ConvertToRGB()
# SeparateFields()
# VD_DeinterlaceSmooth(0,"interpolate",0,24,20,0,0)
# ConvertToYUY2()

################################################## #
# Time Based DeInterlacer by Uwe Freese, v1.1 #
# #
# textpixel_dist (-), color_threshold (0-255), #
# pixel_threshold (0-100), scene_dist (0-100), #
# interpolate_field (0-100) #
# mode = scene_det_off/scene_det_on/bar_graph #
# /scene_changes #
# mode_spat = inter_bottom/inter_top #
# mode_temp_delay_top = inter_top/inter_bottom #
# mode_temp_delay_bottom = inter_bottom/inter_top #
################################################## #

function VD_DeInterlaceTimeBased(clip clip, string "mode", int "textpixel_dist", int "color_threshold",
\ int "pixel_threshold", int "scene_dist", bool "detect_scene", int "interpolate_field", string "mode_spat",
\ string "mode_temp_delay_bottom", string "mode_temp_delay_top")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \tbdi.vdf", "_VD_DeInterlaceTimeBased", 1)
mode = default(mode, "scene_det_on")
mode = (mode=="scene_det_off") ? 0 : (mode=="scene_det_on") ? 1 : (mode=="bar_graph") ? 2 : (mode=="scene_changes") ? 3 : -1
Assert(mode>=0, """VD_DeInterlaceTimeBased: "mode" parameter must be "scene_det_off", "scene_det_on", "bar_graph" or "scene_changes"""")
mode_spat = default(mode_spat, "inter_bottom")
mode_spat = (mode_spat=="inter_bottom") ? 0 : (mode_spat=="inter_top") ? 1 : -1
Assert(mode_spat>=0, """VD_DeInterlaceTimeBased: "mode_spat" parameter must be "inter_bottom" or "inter_top"""")
mode_temp_delay_top = default(mode_temp_delay_top, "inter_top")
mode_temp_delay_top = (mode_temp_delay_top=="inter_top") ? 0 : (mode_temp_delay_top=="inter_bottom") ? 1 : -1
Assert(mode_temp_delay_top>=0, """VD_DeInterlaceTimeBased: "mode_temp_delay_top" parameter must be "inter_top" or "inter_bottom"""")
mode_temp_delay_bottom = default(mode_temp_delay_bottom, "inter_bottom")
mode_temp_delay_bottom = (mode_temp_delay_bottom=="inter_bottom") ? 0 : (mode_temp_delay_bottom=="inter_top") ? 1 : -1
Assert(mode_temp_delay_bottom>=0, """VD_DeInterlaceTimeBased: "mode_temp_delay_bottom" parameter must be "inter_bottom" or "inter_top"""")
return clip._VD_DeInterlaceTimeBased(mode_temp_delay_bott om, mode_temp_delay_top, mode, default(textpixel_dist,1000),
\ default(color_threshold,15), default(pixel_threshold,55), default(scene_dist,5), default(detect_scene,false)?1:0,
\ default(interpolate_field,0), mode_spat)
}

# example:
# ConvertToRGB()
# VD_DeInterlaceTimeBased("scene_det_on", 1000, 15, 55, 5, true, 50, "inter_bottom")
# ConvertToYUY2()

#########################################
# Spatial Smoother by Dividee, v1.0 #
# #
# diameter (3-11, odd), strength (0-18) #
#########################################

function VD_SpatialSmoother(clip clip, int "diameter", int "strength")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \ssmooth.vdf", "_VD_SpatialSmoother")
return clip._VD_SpatialSmoother(default(diameter,5), default(strength,3))
}

# example:
# ConvertToRGB()
# VD_SpatialSmoother(5,3)
# ConvertToYUY2()

###############################################
# Denoise by tHE fISH, v1.0 #
# #
# The output of this filter is 100% identical #
# to the output of the deflicker filter with #
# a window size of 1 ! #
# #
# softening (0-?) #
###############################################

function VD_Denoise(clip clip, int "softening")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \Denoise.vdf", "_VD_Denoise", 10)
return clip._VD_Denoise(default(softening,10))
}

# example:
# ConvertToRGB()
# VD_Denoise(10)
# ConvertToYUY2()

#####################################
# PicFix by Gabest, v1.04 #
# #
# threshold (0-16), error_cor (0-4) #
#####################################

function VD_PicFix(clip clip, int "threshold", int "error_cor")
{
LoadVirtualdubPlugin(VirtualDub_plugin_directory+" \picfix.dll", "_VD_PicFix")
return clip._VD_PicFix(default(threshold,6), default(error_cor,3))
}

# example:
# ConvertToRGB()
# VD_PicFix(6,3)
# ConvertToYUY2()
# ------ End of Script for VDub_Filters

-black prince 8)