Stuff in public: section of AVSValue (from VERSION 3 Header, ie valid in v2.58 onwards).
class AVSValue {
public:
AVSValue() { type = 'v'; }
AVSValue(IClip* c) { type = 'c'; clip = c; if (c) c->AddRef(); }
AVSValue(const PClip& c) { type = 'c'; clip = c.GetPointerWithAddRef(); }
AVSValue(bool b) { type = 'b'; boolean = b; }
AVSValue(int i) { type = 'i'; integer = i; }
// AVSValue(__int64 l) { type = 'l'; longlong = l; }
AVSValue(float f) { type = 'f'; floating_pt = f; }
AVSValue(double f) { type = 'f'; floating_pt = float(f); }
AVSValue(const char* s) { type = 's'; string = s; }
AVSValue(const AVSValue* a, int size) { type = 'a'; array = a; array_size = size; }
AVSValue(const AVSValue& v) { Assign(&v, true); }
~AVSValue() { if (IsClip() && clip) clip->Release(); }
AVSValue& operator=(const AVSValue& v) { Assign(&v, false); return *this; }
// Note that we transparently allow 'int' to be treated as 'float'.
// There are no int<->bool conversions, though.
bool Defined() const { return type != 'v'; }
bool IsClip() const { return type == 'c'; }
bool IsBool() const { return type == 'b'; }
bool IsInt() const { return type == 'i'; }
// bool IsLong() const { return (type == 'l'|| type == 'i'); }
bool IsFloat() const { return type == 'f' || type == 'i'; }
bool IsString() const { return type == 's'; }
bool IsArray() const { return type == 'a'; }
PClip AsClip() const { _ASSERTE(IsClip()); return IsClip()?clip:0; }
bool AsBool() const { _ASSERTE(IsBool()); return boolean; }
int AsInt() const { _ASSERTE(IsInt()); return integer; }
// int AsLong() const { _ASSERTE(IsLong()); return longlong; }
const char* AsString() const { _ASSERTE(IsString()); return IsString()?string:0; }
double AsFloat() const { _ASSERTE(IsFloat()); return IsInt()?integer:floating_pt; }
bool AsBool(bool def) const { _ASSERTE(IsBool()||!Defined()); return IsBool() ? boolean : def; }
int AsInt(int def) const { _ASSERTE(IsInt()||!Defined()); return IsInt() ? integer : def; }
double AsFloat(double def) const { _ASSERTE(IsFloat()||!Defined()); return IsInt() ? integer : type=='f' ? floating_pt : def; }
const char* AsString(const char* def) const { _ASSERTE(IsString()||!Defined()); return IsString() ? string : def; }
int ArraySize() const { _ASSERTE(IsArray()); return IsArray()?array_size:1; }
const AVSValue& operator[](int index) const {
_ASSERTE(IsArray() && index>=0 && index<array_size);
return (IsArray() && index>=0 && index<array_size) ? array[index] : *this;
}
For the IsArray() thing:
https://forum.doom9.org/showthread.php?p=1538558#post1538558
#ifdef AVISYNTH_PLUGIN_25
extern "C" __declspec(dllexport) const char* __stdcall AvisynthPluginInit2(IScriptEnvironment* env){
OutputDebugString(AVISYNTHNAME ": AvisynthPluginInit2 Calling env->AddFunction\n");
#else
/* New 2.6 requirement!!! */
// Declare and initialise server pointers static storage.
const AVS_Linkage *AVS_linkage = 0;
/* New 2.6 requirement!!! */
// DLL entry point called from LoadPlugin() to setup a user plugin.
extern "C" __declspec(dllexport) const char* __stdcall
AvisynthPluginInit3(IScriptEnvironment* env, const AVS_Linkage* const vectors) {
/* New 2.6 requirment!!! */
// Save the server pointers.
AVS_linkage = vectors;
OutputDebugString(AVISYNTHNAME ": AvisynthPluginInit3 Calling env->AddFunction\n");
#endif
// The code below, registers the plugin with avisynth and tells it how to construct/create
// the filter, the argument types it accepts and whether they are optional/named arguments.
// AddFunction has the following paramters:
// AddFunction(FilterName , Arguments, Function-to-call,0);
env->AddFunction(
AVISYNTHNAME, // The name of the filter in Avisynth (as a string).
"c[intarg]i[version]b[show]b[bounce]i", // Arguments, THIS MUST BE EDITED TO SUIT THE FILTER ARGUMENTS.
Create_INTERNALNAME, // The function Avisynth will call to create an instance of the filter.
0 // Zero. (possibly 'user_data' arg in Create_INTERNALNAME, never seen used).
);
// This particular registration, says:
// The name of the filter in Avisynth is AVISYNTHNAME().
// First filter arg 'c' is an un-named compulsory clip ('[name]' means 'name' is optional),
// Second filter arg '[intarg]i' is an optional arg of type int.
// Third filter arg '[version]b' is an optional arg of type bool.
// Forth filter arg '[show]b' is an optional arg of type bool.
// Fifth filter arg '[bounce]i' is an optional arg of type int.
// In this case the filter is similar to an Avisynth script definition of
// AVISYNTHNAME(clip,int "intarg",bool "version",bool "show", int "bounce").
// Of course, this must match what it uses in the above Avisynth Filter Creation function,
// and is almost always what the class constructor accepts.
// Arguments is a string that defines the types and optional names of the arguments for your filter.
// The names of optional arguments are enclosed in '[]' as in [name] and followed by the type string specifier.
// An argument list of eg "cc" would indicate a filter requiring two compulsory un-named clips.
// An arg list of eg "c[]c" would indicate a filter accepting a compulsory un-named clip and an
// optional un-named clip, without the '[]' in the arg list string, Avisynth would NOT allow you to call
// the filter without both clips even if you gave a default value in the 'Create_INTERNALNAME' filter creator
// (previous function above).
// Argument type specifier strings.
// c - Video Clip
// i - Integer number
// f - Float number
// s - String
// b - boolean
// . - Any type (dot)
// Array Specifiers
// i* - Integer Array, zero or more
// i+ - Integer Array, one or more
// .* - Any type Array, zero or more
// .+ - Any type Array, one or more
// Etc
#ifdef AVISYNTH_PLUGIN_25
OutputDebugString(AVISYNTHNAME ": AvisynthPluginInit2 returning to Avisynth\n");
#else
OutputDebugString(AVISYNTHNAME ": AvisynthPluginInit3 returning to Avisynth\n");
#endif
// return "'Example' Example plugin";
return ("'" AVISYNTHNAME "' " AVISYNTHNAME " plugin");
// A freeform name of the plugin. Dont think this returned string is actually used for anything in Avisynth.
}