RT_Stats, Compile-time/Runtime Functions v1.43 - 08 Oct 2014

[StainlessS]

As you use

RT_ArrayAlloc(AWB_Array%%%, Type=2, Dim1=cRGB.FrameCount, Dim2=4)

I presume that R,G,B are float, frame number would also be stored float, however as you are creating array for entire frame set, you dont
need frame number in array, ie array(n,0) would be n.
If you were wanting individual selected frame numbers with R,G,B as float, then would myself use two arrays, one for framenum and one for R,G,B,
(or 1x dim1=2 array of int packed as single int if RGB 0->255, with frame numbers in arr(n,0))

The call to CallCmd looks wrong to me, "-3" means 3 frames but missing start frame (as trim ie trim(10,-3) would be frames 10,11,12)
Dont think you can use CallCmd inside Scriptclip although its a long time since I used it (at least not to delete file).
What is the intention of -3 ?

Am currently playing with (just started about an hour ago) a DBase thing, up to 16 fields per record of same types as ARRAY but mixed types in record fields.

going to pub now, be good

[martin53]

Wanted an array with first dimension frame number, second dimension 4 (meanwhile 3) to store R, G and B values per frame.

Definition:
RT_ArrayAlloc(gbDone%%%, Type=0, Dim1=cRGB.FrameCount)
RT_ArrayAlloc(gfRGB%%%, Type=2, Dim1=cRGB.FrameCount, Dim2=3)

Write:
RT_ArraySet(gfRGB%%%, R, current_frame+delta, 0)
RT_ArraySet(gfRGB%%%, G, current_frame+delta, 1)
RT_ArraySet(gfRGB%%%, B, current_frame+delta, 2)

Read:
R = RT_ArrayGet(gfRGB%%%, current_frame+delta, 0)
G = RT_ArrayGet(gfRGB%%%, current_frame+delta, 1)
B = RT_ArrayGet(gfRGB%%%, current_frame+delta, 2)

(you guessed it, g is for global, b is for bool, f for float, then comes the speaking part of the variable name and the marker string for the instance number)

... so did not want to store frame number itself, but only use it as index. cRGB is the clip. Can you please provide me an example if I misunderstood this?

CallCmd is not inside ScriptClip, sorry my sketch was poor. It is after the ScriptClip in the clip graph. I use the CallCmd version you improved based on Nic's (October 2012). CallCmd.txt Line 74 says "-3 = In Destructor (after last frame)" and that's what I want...

[StainlessS]

I changed frame range spec several versions ago (while still beta). Get later version with open/close options. (CallCmd)
EDIT: frame range spec was changed before it had it's own thread, while was still posting in original Nic Call() thread.
You have used later versions since then.
CallCmd thread is a few posts after this one at date of this post, indeed you posted in it a few days back.
CallCmd here:- http://forum.doom9.org/showthread.php?t=166063


As far the rest of your post, looks good to me.

EDIT: With current CallCmd, suggest something like (untested)

  CallCmd(Close="CMD /C /Q del " + Chr(34) + AWB_Array%%% + Chr(34) ,Hide=True)

EDIT: Might be worth seeing if you can get CallCmd CLI command to do a wildcard arrays delete if multiple used per instance.
eg something like "gfRGB%%%.ARR" to "*RGB%%%.ARR"

EDIT: Added /Q switch to DEL command, "/Q Quiet mode, do not ask if ok to delete on global wildcard", maybe not necessary.

[StainlessS]

Page #1 of 3

New version, RT_Stats v1.28, see 1st post. (Added Array funcs pretty much as previous posted EDIT: v1.28Beta51)

Beta version v0.0Beta RT_DBase (will be added to RT_Stats), working well.
Here:- LINK REMOVED, Added to RT_Stats

*****************************************************
**********       DBASE FUNCTIONS          ***********
*****************************************************

RT_DBaseAlloc(String Filename,Int Records,String TypeString,Int "StringLenMax"=256)
 Creates a file to hold DataBase records. Each record can have up to 16 fields of varying type, Bool, Int, Float, String, or BIN.
  BIN is a BYTE (8 bit) sized Int where only lowest 8 bits of Int are stored in array as an unsigned 8 bit int, upper 24 bits ignored.

 Filename, DBASE Filename, no default.

 Records, int zero or more. Number of records to create, initalized to zeros (initialized to zeros, Bool=False,Float=0.0,String="").

 TypeString, string holding record construction data. One character for each field, valid characters are "bifsn" or Uppercase.
  'b' = BOOL, 'i' = INT, 'f' = FLOAT, 'S' = STRING, 'n' = BIN.
  The 's' STRING construction character can be followed by numeric digits describing maximum string length of fixed string (excluding
    any nul term character), otherwise StringLenMax is used by default instead.

 StringLenMax Default=256. Default length of String fields if no explicit string length defined following TypeString S constructor char.

 Example TypeString:-
   "ifffs1024bsn", 1st field Int, 3 Float fields, 1 string field of length=1024, 1 Bool field, 1 string field using length of
   StringLenMax, and 1 BIN field. 8 Fields in all (0->7).
 Returns number of records created.

***
***
***

RT_DBaseFields(String Filename)
 Filename, DBASE Filename, no default.
 Return number of fields per record.

***
***
***

RT_DBaseFieldType(String Filename,Int Field)
 Filename, DBASE Filename, no default.
 Field, range 0 -> RT_DBaseFields(Filename) - 1
 Return type of Field. 0=Bool, 1=Int, 2 = Float, 3 = String, 4 = BIN.

***
***
***

RT_DBaseFieldSize(String Filename,Int Field)
 Filename, DBASE Filename, no default.
 Field, range 0 -> RT_DBaseFields(Filename) - 1
 Return size of Field in bytes. Bool=1, Int=4, Float=4, String length as set by RT_DBaseAlloc(), BIN=1.

***
***
***

RT_DBaseRecords(String Filename)
 Filename, DBASE Filename, no default.
 Returns current number of records in Filename database.

***
***
***

RT_DBaseRecordSize(String Filename)
 Filename, DBASE Filename, no default.
 Returns record size, ie sum of field sizes.

***
***
***

RT_DBaseRecordsMax(String Filename)
 Filename, DBASE Filename, no default.
 Returns maximum theoretical number of records that could be stored in file based on (Maximum +ve int - header size) / Record Size.
  (where record size is sum of all field sizes).

***
***
***

RT_DBaseGetField(String Filename,Int Record,Int Field)
 Filename, DBASE Filename, no default.
 Record, range 0 -> RT_DBaseRecords(Filename) - 1
 Field, range  0 -> RT_DBaseFields(Filename)  - 1
 Returns contents of a field belonging to the particular record.

***
***
***

RT_DBaseSetField(String Filename,Int Record,Int Field, Var)
 Sets a single Field in a Record to Var.
 Filename, DBASE Filename, no default.
 Record, range 0 -> RT_DBaseRecords(Filename) - 1
 Field, range  0 -> RT_DBaseFields(Filename)  - 1
 Var, variable of type as set by RT_DBaseAlloc().
 Returns the current number of records.

***
***
***

RT_DBaseSet(String Filename,Int Record, Var_1, ... , Var_n)
 Simultaneously sets all fields of a record. All fields must be supplied.
 Filename, DBASE Filename, no default.
 Record, range 0 -> RT_DBaseRecords(Filename) - 1
 Var_1, ... ,Var_n, Field variables of types as set by RT_DBaseAlloc().
 Returns the current number of records.

***
***
***

RT_DBaseExtend(String Filename,Int "Add"=1)
 Adds a number of blank records to Filename Database. (initialized to zeros, Bool=False, Float=0.0, String="").
 Filename, DBASE Filename, no default.
 Add, Int default 1, Number of blank records to add to the DataBase.
 Returns the current number of records.

***
***
***

RT_DBaseAppend(String Filename, FieldVar_1, ... , FieldVar_n)
 Creates a record from Field Vars and appends it to the end of the DataBase file. All fields must be supplied.
 Filename, DBASE Filename, no default.
 FieldVar_1, ... , FieldVar_n. A variable for each field of type as set by RT_DBaseAlloc().
 Returns the current number of records.

***
***
***

RT_DBaseGetAttrib(String Filename,Int ix)
 There are 16 available attributes in the DataBase file header, that can be used for whatever purpose you like,
 Filename, DBASE Filename, no default.
 Ix, Attribute array element index range 0 -> 15.
 Returns the value of the user set attribute Int or Float (or type Int 0 if not yet set).

***
***
***

RT_DBaseSetAttrib(String Filename,Int ix, Var)
 There are 16 available attributes in the DataBase file header, that can be used for whatever purpose you like,
  RT_DBaseAlloc() initializes all Attributes to type Int, 0.
 Filename, DBASE Filename, no default.
 Ix, Attribute array element index range 0 -> 15.
 Value, Int or Float, The value that Attrib(ix) will be set to.
 Returns Value. Error if type not of type Int or type Float.

[StainlessS]

Page #2 of 3

# DBase_Timer_Test.Avs - As Knowledge of fields in record not hard coded, cannot test Extend/Append (too long gen random data).

/*

RT_DBaseAlloc(String Filename,Int Records,String TypeString,Int "StringLenMax"=256)
RT_DBaseFields(String Filename)
RT_DBaseFieldType(String Filename,Int Field)
RT_DBaseFieldSize(String Filename,Int Field)
RT_DBaseRecords(String Filename)
RT_DBaseRecordSize(String Filename)
RT_DBaseRecordsMax(String Filename)
RT_DBaseGetField(String Filename,Int Record,Int Field)
RT_DBaseSetField(String Filename,Int Record,Int Field, Var)
RT_DBaseSet(String Filename,Int Record, Var1, ... , Varn)
RT_DBaseExtend(String Filename,Int Add)
RT_DBaseAppend(String Filename, Var_1, ... , Var_n)
RT_DBaseGetAttrib(String Filename,Int ix)
RT_DBaseSetAttrib(String Filename,Int ix, Var)

*/

# Config
DB                      = "DBASE.RDB"       # DBase FileName
TYPESTRING              = "bifs64n"         # Describes the DBase Fields and optional size of any String Fields
                                            # b=Bool, i=Int,f=Float,s=String(eg "s256" is StringLen=256),n=BIN.
RECORDS                 = 100000            # Initial number of records in DBase
DEFAULT_STRINGLENMAX    = 256               # If TYPESTRING type 's' String type Field does not have explicit size trailer.
DELETE                  = False

##################################
TYPENAMES=RT_String("Bool\nInt\nFloat\nString\nBin\n")
ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALPHA=ALPHA+ALPHA # Len 260
GScript("""
    TOTAL_START=RT_Timer()
    RT_DebugF("DBase_Timer_Test.Avs")
    START=RT_Timer()
    RT_DBaseAlloc(DB,RECORDS,TYPESTRING,stringlenmax=DEFAULT_STRINGLENMAX)
    STOP=RT_Timer()
    RT_DebugF("TYPESTRING   = %c%s%c",34,TYPESTRING,34)
    RT_DebugF("Records      = %d",RT_DBaseRecords(DB))
    RT_DebugF("RecordSize   = %d",RT_DBaseRecordSize(DB))
    RT_DebugF("RecordsMax   = %d ($%X)",RT_DBaseRecordsMax(DB),RT_DBaseRecordsMax(DB))
    FIELDS=RT_DBaseFields(DB)
    RT_DebugF("Fields       = %d",FIELDS)
    for(i=0,Fields - 1) {
        TYPE_S=RT_TxtGetLine(TYPENAMES,RT_DBaseFieldType(DB,i))
        RT_DebugF("  %2d ) Type = %d(%6s) Size = %d",i,RT_DBaseFieldType(DB,i),TYPE_S,RT_DBaseFieldSize(DB,i))
    }
    RT_DebugF("RT_DBaseAlloc() = %.3f secs (Per Field Ave %f microsecs)",STOP-START,1000000.0*(STOP-START)/(RECORDS*FIELDS))
    RT_DebugF("Check Init")
    START_INIT=RT_Timer()
    # You would likely know the Types in your own database (we do not, MUCH SLOWER as we have to inquire from DBASE on each Field Interation)
    # Probably faster to do nested Record, Field, if we knew DBASE types in advance
    for(field=0,FIELDS - 1) {
        type = RT_DBaseFieldType(DB,field)  # You would likely know the types of your own database.
        TYPE_S=RT_TxtGetLine(TYPENAMES,type)
        vs=Select(type,False,0,0.0,"",0)
        RT_DebugF("Check Init on field %d Type=%d(%6s)",field,type,TYPE_S)
        START=RT_Timer()
        for(record=0,RECORDS - 1 ) {
            vg=RT_DBaseGetField(DB,record,field)
            if(vg != vs) {
                RT_DebugF("ERROR, Record:Field %d:%d Type %d Set=%s Get=%s",record,field,type,String(vs),String(vg))
            }
        }
        STOP=RT_Timer()
        RT_DebugF("Check Init on field %d Type=%d(%6s) = %.3f secs (Per field Ave %f microsecs)",field,type,TYPE_S,STOP-START,1000000.0*(STOP-START)/RECORDS)
    }
    STOP_INIT=RT_Timer()
    RT_DebugF("TOTAL Check Init = %.3f secs (Per Field Ave %f microsecs)",STOP_INIT-START_INIT,1000000.0*(STOP_INIT-START_INIT)/(RECORDS*FIELDS))
    Try {RT_DBaseGetField(RT_DBaseRecords(DB),0)RT_DebugF("Init END Check FAILED")} catch (err) {RT_DebugF("Init END Check Passed")}
    RT_DebugF("Check Attributes Set/Get")
    START=RT_Timer()
    for(i=0,15) {
        vs= (i % 2 == 0) ? i*1000 : i * PI      # Test Int and Float Attributes
        type=(i % 2 == 0) ? 1 : 2
        RT_DBaseSetAttrib(DB,i,vs)
        vg = RT_DBaseGetAttrib(DB,i)
        if(vg != vs) {
            RT_DebugF("%d) TYPE=%d SetAttrib/GetAttrib Error, Set = %s Get = %s",i,type,String(vs),String(vg))
        }
    }
    STOP=RT_Timer()
    RT_DebugF("Check Attributes Set/Get = %.3f secs (Per element Ave %f microsecs)",STOP-START,1000000.0*(STOP-START)/16)

    RT_DebugF("Check Set/Get Compare")
    Rand(seed=true)
    START_SETGET=RT_Timer()
    for(field=0,FIELDS - 1) {
        type = RT_DBaseFieldType(DB,field)
        TYPE_S=RT_TxtGetLine(TYPENAMES,field)
        fieldsize=RT_DBaseFieldSize(DB,field)
        rnd=Rand() + 1  # ALL fields types set same as just timing
        RT_DebugF("Check Set on field %d Type=%d(%6s)",field,type,TYPE_S)
        vs=Select(Type,RT_BitTst(rand,0),rand,Float(rand),RightStr(ALPHA + "_" + String(rand),fieldsize) ,RT_BitAnd(rand,$FF))
        START=RT_Timer()
        for(record=0,RECORDS - 1 ) {
            RT_DBaseSetField(DB,record,field, vs)
        }
        STOP=RT_Timer()
        RT_DebugF("Check Set on field %d Type=%d(%6s) = %.3f secs (Per field Ave %f microsecs)",field,type,TYPE_S,STOP-START,1000000.0*(STOP-START)/RECORDS)
        RT_DebugF("Check Get on field %d Type=%d(%6s)",field,type,TYPE_S)
        START=RT_Timer()
        for(record=0,RECORDS - 1 ) {
            vg=RT_DBaseGetField(DB,record,field)
            if(vg != vs) {
                RT_DebugF("ERROR, Record:Field %d:%d Type %d Set=%s Get=%s",record,field,type,String(vs),String(vg))
            }
        }
        STOP=RT_Timer()
        RT_DebugF("Check Get on field %d Type=%d(%6s) = %.3f secs (Per field Ave %f microsecs)",field,type,TYPE_S,STOP-START,1000000.0*(STOP-START)/RECORDS)
    }
    STOP_SETGET=RT_Timer()
    RT_DebugF("TOTAL Check Set/Get Compare = %.3f secs (Per field Ave %f microsecs)",STOP_SETGET-START_SETGET,1000000.0*(STOP_SETGET-START_SETGET)/(RECORDS*FIELDS))
    TOTAL_STOP=RT_Timer()
    RT_DebugF("TOTAL SCRIPT TIME = %.3f seconds",TOTAL_STOP-TOTAL_START)
    (DELETE) ? RT_FileDelete(DB) : NOP
""")
colorbars.KillAudio

log

00000001    0.00000000  RT_DebugF: DBase_Timer_Test.Avs
00000002    0.02195171  RT_DebugF: TYPESTRING   = "bifs64n"
00000003    0.02216067  RT_DebugF: Records      = 100000
00000004    0.02236121  RT_DebugF: RecordSize   = 74
00000005    0.02266201  RT_DebugF: RecordsMax   = 29020045 ($1BACF8D)
00000006    0.02283370  RT_DebugF: Fields       = 5
00000007    0.02320408  RT_DebugF:    0 ) Type = 0(  Bool) Size = 1
00000008    0.02356772  RT_DebugF:    1 ) Type = 1(   Int) Size = 4
00000009    0.02393370  RT_DebugF:    2 ) Type = 2( Float) Size = 4
00000010    0.02430234  RT_DebugF:    3 ) Type = 3(String) Size = 64
00000011    0.02467171  RT_DebugF:    4 ) Type = 4(   Bin) Size = 1
00000012    0.02478274  RT_DebugF: RT_DBaseAlloc() = 0.031 secs (Per Field Ave 0.062000 microsecs)
00000013    0.02487412  RT_DebugF: Check Init
00000014    0.02558443  RT_DebugF: Check Init on field 0 Type=0(  Bool)
00000015    8.00883389  RT_DebugF: Check Init on field 0 Type=0(  Bool) = 7.984 secs (Per field Ave 79.839996 microsecs)
00000016    8.00947380  RT_DebugF: Check Init on field 1 Type=1(   Int)
00000017    15.78374863 RT_DebugF: Check Init on field 1 Type=1(   Int) = 7.766 secs (Per field Ave 77.660004 microsecs)
00000018    15.78439236 RT_DebugF: Check Init on field 2 Type=2( Float)
00000019    23.52473068 RT_DebugF: Check Init on field 2 Type=2( Float) = 7.750 secs (Per field Ave 77.500000 microsecs)
00000020    23.52537155 RT_DebugF: Check Init on field 3 Type=3(String)
00000021    31.30543900 RT_DebugF: Check Init on field 3 Type=3(String) = 7.781 secs (Per field Ave 77.809998 microsecs)
00000022    31.30608177 RT_DebugF: Check Init on field 4 Type=4(   Bin)
00000023    39.04590607 RT_DebugF: Check Init on field 4 Type=4(   Bin) = 7.734 secs (Per field Ave 77.340012 microsecs)
00000024    39.04608154 RT_DebugF: TOTAL Check Init = 39.015 secs (Per Field Ave 78.030006 microsecs)
00000025    39.04807663 RT_DebugF: Init END Check Passed
00000026    39.04816818 RT_DebugF: Check Attributes Set/Get
00000027    39.05691910 RT_DebugF: Check Attributes Set/Get = 0.016 secs (Per element Ave 999.927490 microsecs)
00000028    39.05701065 RT_DebugF: Check Set/Get Compare
00000029    39.05791855 RT_DebugF: Check Set on field 0 Type=0(  Bool)
00000030    50.78600693 RT_DebugF: Check Set on field 0 Type=0(  Bool) = 11.734 secs (Per field Ave 117.340012 microsecs)
00000031    50.78610229 RT_DebugF: Check Get on field 0 Type=0(  Bool)
00000032    59.15937424 RT_DebugF: Check Get on field 0 Type=0(  Bool) = 8.375 secs (Per field Ave 83.750000 microsecs)
00000033    59.15987396 RT_DebugF: Check Set on field 1 Type=1(   Int)
00000034    70.91230011 RT_DebugF: Check Set on field 1 Type=1(   Int) = 11.750 secs (Per field Ave 117.499962 microsecs)
00000035    70.91239929 RT_DebugF: Check Get on field 1 Type=1(   Int)
00000036    79.30217743 RT_DebugF: Check Get on field 1 Type=1(   Int) = 8.391 secs (Per field Ave 83.909988 microsecs)
00000037    79.30267334 RT_DebugF: Check Set on field 2 Type=2( Float)
00000038    91.03527832 RT_DebugF: Check Set on field 2 Type=2( Float) = 11.734 secs (Per field Ave 117.340012 microsecs)
00000039    91.03538513 RT_DebugF: Check Get on field 2 Type=2( Float)
00000040    99.40809631 RT_DebugF: Check Get on field 2 Type=2( Float) = 8.375 secs (Per field Ave 83.750000 microsecs)
00000041    99.40859985 RT_DebugF: Check Set on field 3 Type=3(String)
00000042    111.33905792    RT_DebugF: Check Set on field 3 Type=3(String) = 11.922 secs (Per field Ave 119.220047 microsecs)
00000043    111.33914948    RT_DebugF: Check Get on field 3 Type=3(String)
00000044    119.83779144    RT_DebugF: Check Get on field 3 Type=3(String) = 8.500 secs (Per field Ave 85.000000 microsecs)
00000045    119.83829498    RT_DebugF: Check Set on field 4 Type=4(   Bin)
00000046    131.56878662    RT_DebugF: Check Set on field 4 Type=4(   Bin) = 11.735 secs (Per field Ave 117.350014 microsecs)
00000047    131.56887817    RT_DebugF: Check Get on field 4 Type=4(   Bin)
00000048    139.94674683    RT_DebugF: Check Get on field 4 Type=4(   Bin) = 8.375 secs (Per field Ave 83.750000 microsecs)
00000049    139.94692993    RT_DebugF: TOTAL Check Set/Get Compare = 100.891 secs (Per field Ave 201.782013 microsecs)
00000050    139.94709778    RT_DebugF: TOTAL SCRIPT TIME = 139.953 seconds

[StainlessS]

Page #3 of 3

# DBase_Append_Test.Avs - Knowledge of fields in record, can test Extend/Append

/*

RT_DBaseAlloc(String Filename,Int Records,String TypeString,Int "StringLenMax"=256)
RT_DBaseFields(String Filename)
RT_DBaseFieldType(String Filename,Int Field)
RT_DBaseFieldSize(String Filename,Int Field)
RT_DBaseRecords(String Filename)
RT_DBaseRecordSize(String Filename)
RT_DBaseRecordsMax(String Filename)
RT_DBaseGetField(String Filename,Int Record,Int Field)
RT_DBaseSetField(String Filename,Int Record,Int Field, Var)
RT_DBaseSet(String Filename,Int Record, Var1, ... , Varn)
RT_DBaseExtend(String Filename,Int Add)
RT_DBaseAppend(String Filename, Var_1, ... , Var_n)
RT_DBaseGetAttrib(String Filename,Int ix)
RT_DBaseSetAttrib(String Filename,Int ix, Var)

*/

# Config
DB                      = "DBASE.RDB"       # DBase FileName
RECORDS                 = 10000             # Initial number of records in DBase
DELETE                  = False
##################################
GScript("""
    TYPENAMES=RT_String("Bool\nInt\nFloat\nString\nBin\n")
    SLEN=64
    TYPESTRING=RT_String("bifs%dn",SLEN)
    RT_DebugF("DBase_Append_Test.Avs")
    RT_DBaseAlloc(DB,0,TYPESTRING)
    RT_DebugF("TYPESTRING   = %c%s%c",34,TYPESTRING,34)
    RT_DebugF("Records      = %d",RT_DBaseRecords(DB))
    RT_DebugF("RecordSize   = %d",RT_DBaseRecordSize(DB))
    RT_DebugF("RecordsMax   = %d ($%X)",RT_DBaseRecordsMax(DB),RT_DBaseRecordsMax(DB))
    FIELDS=RT_DBaseFields(DB)
    RT_DebugF("Fields       = %d",FIELDS)
    for(i=0,Fields - 1) {
        TYPE_S=RT_TxtGetLine(TYPENAMES,RT_DBaseFieldType(DB,i))
        RT_DebugF("  %2d ) Type = %d(%6s) Size = %d",i,RT_DBaseFieldType(DB,i),TYPE_S,RT_DBaseFieldSize(DB,i))
    }
    RT_DebugF("Extending to %d records",RECORDS)
    RT_DBaseExtend(DB,RECORDS)
    RT_DebugF("Check Extended Init To Zero")
    vs_0 = False vs_1 = 0 vs_2 = 0.0 vs_3 = "" vs_4 = 0
    for(record=0,RECORDS - 1 ) {
        vg_0=RT_DBaseGetField(DB,record,0)
        vg_1=RT_DBaseGetField(DB,record,1)
        vg_2=RT_DBaseGetField(DB,record,2)
        vg_3=RT_DBaseGetField(DB,record,3)
        vg_4=RT_DBaseGetField(DB,record,4)
        if((vs_0 != vg_0) || (vs_1 != vg_1) || (vs_2 != vg_2) || (vs_3 != vg_3) || (vs_4 != vg_4)) {
            RT_DebugF("ERROR, @ Record %d",record)
        }
    }
    Try {RT_DBaseGetField(RT_DBaseRecords(DB),0)RT_DebugF("Init END Check FAILED")} catch (err) {RT_DebugF("Init END Check Passed")}
    RT_DebugF("RT_DBaseSet")
    for(record=0,RECORDS - 1 ) {
        vs_0 = RT_BitTst(record,0)
        vs_1 = record
        vs_2 = Float(record)
        vs_3 = RT_StrPad("",SLEN,Chr((record % 25) + 65))
        vs_4 = RT_BitAnd(record,$FF)
        RT_DBaseSet(DB,record,vs_0,vs_1,vs_2,vs_3,vs_4)
    }
    RT_DebugF("RT_DBaseSet/Get Compare")
    for(record=0,RECORDS - 1 ) {
        vs_0 = RT_BitTst(record,0)
        vs_1 = record
        vs_2 = Float(record)
        vs_3 = RT_StrPad("",SLEN,Chr((record % 25) + 65))
        vs_4 = RT_BitAnd(record,$FF)
        vg_0=RT_DBaseGetField(DB,record,0)
        vg_1=RT_DBaseGetField(DB,record,1)
        vg_2=RT_DBaseGetField(DB,record,2)
        vg_3=RT_DBaseGetField(DB,record,3)
        vg_4=RT_DBaseGetField(DB,record,4)
        if((vs_0 != vg_0) || (vs_1 != vg_1) || (vs_2 != vg_2) || (vs_3 != vg_3) || (vs_4 != vg_4)) {
            RT_DebugF("ERROR, @ Record %d",record)
        }
    }
    RT_DebugF("RT_DBase Append()")
    for(i=RECORDS,RECORDS*2 - 1 ) {
        vs_0 = RT_BitTst(i,0)
        vs_1 = i
        vs_2 = Float(i)
        vs_3 = RT_StrPad("",SLEN,Chr((i % 25) + 65))
        vs_4 = RT_BitAnd(i,$FF)
        RT_DBaseAppend(DB,vs_0,vs_1,vs_2,vs_3,vs_4)
    }
    RT_DebugF("RT_DBaseAppend() Compare")
    for(i=RECORDS,RECORDS*2 - 1 ) {
        vs_0 = RT_BitTst(i,0)
        vs_1 = i
        vs_2 = Float(i)
        vs_3 = RT_StrPad("",SLEN,Chr((i % 25) + 65))
        vs_4 = RT_BitAnd(i,$FF)
        vg_0=RT_DBaseGetField(DB,i,0)
        vg_1=RT_DBaseGetField(DB,i,1)
        vg_2=RT_DBaseGetField(DB,i,2)
        vg_3=RT_DBaseGetField(DB,i,3)
        vg_4=RT_DBaseGetField(DB,i,4)
        if((vs_0 != vg_0) || (vs_1 != vg_1) || (vs_2 != vg_2) || (vs_3 != vg_3) || (vs_4 != vg_4)) {
            RT_DebugF("ERROR, @ Record %d",record)
        }
    }
    Try {RT_DBaseGetField(DB,RECORDS*2-1,4) RT_DebugF("FINAL_END_1 Check PASSED")} catch (err) {RT_DebugF("FINAL_END_1 Check FAILED")}
    Try {RT_DBaseGetField(DB,RECORDS*2,0)   RT_DebugF("FINAL_END_2 Check FAILED")} catch (err) {RT_DebugF("FINAL_END_2 Check PASSED")}
    RT_DebugF("TYPESTRING   = %c%s%c",34,TYPESTRING,34)
    RT_DebugF("Records      = %d (Should be %d)",RT_DBaseRecords(DB),RECORDS*2)
    RT_DebugF("RecordSize   = %d",RT_DBaseRecordSize(DB))
    RT_DebugF("RecordsMax   = %d ($%X)",RT_DBaseRecordsMax(DB),RT_DBaseRecordsMax(DB))
    FIELDS=RT_DBaseFields(DB)
    RT_DebugF("Fields       = %d",FIELDS)
    for(i=0,Fields - 1) {
        TYPE_S=RT_TxtGetLine(TYPENAMES,RT_DBaseFieldType(DB,i))
        RT_DebugF("  %2d ) Type = %d(%6s) Size = %d",i,RT_DBaseFieldType(DB,i),TYPE_S,RT_DBaseFieldSize(DB,i))
    }
    RT_DebugF("ALL DONE")
    (DELETE) ? RT_FileDelete(DB) : NOP
""")
colorbars.KillAudio

log

00000001    0.00000000  RT_DebugF: DBase_Append_Test.Avs
00000002    0.00174137  RT_DebugF: TYPESTRING   = "bifs64n"
00000003    0.00192230  RT_DebugF: Records      = 0
00000004    0.00209310  RT_DebugF: RecordSize   = 74
00000005    0.00236371  RT_DebugF: RecordsMax   = 29020045 ($1BACF8D)
00000006    0.00253493  RT_DebugF: Fields       = 5
00000007    0.00290801  RT_DebugF:    0 ) Type = 0(  Bool) Size = 1
00000008    0.00327155  RT_DebugF:    1 ) Type = 1(   Int) Size = 4
00000009    0.00363812  RT_DebugF:    2 ) Type = 2( Float) Size = 4
00000010    0.00399721  RT_DebugF:    3 ) Type = 3(String) Size = 64
00000011    0.00435195  RT_DebugF:    4 ) Type = 4(   Bin) Size = 1
00000012    0.00444715  RT_DebugF: Extending to 10000 records
00000013    0.00640291  RT_DebugF: Check Extended Init To Zero
00000014    3.87600493  RT_DebugF: Init END Check Passed
00000015    3.87609553  RT_DebugF: RT_DBaseSet
00000016    11.99874210 RT_DebugF: RT_DBaseSet/Get Compare
00000017    22.74699402 RT_DebugF: RT_DBase Append()
00000018    31.03572845 RT_DebugF: RT_DBaseAppend() Compare
00000019    41.88741302 RT_DebugF: FINAL_END_1 Check PASSED
00000020    41.88766479 RT_DebugF: FINAL_END_2 Check PASSED
00000021    41.88776398 RT_DebugF: TYPESTRING   = "bifs64n"
00000022    41.88793945 RT_DebugF: Records      = 20000 (Should be 20000)
00000023    41.88810730 RT_DebugF: RecordSize   = 74
00000024    41.88834381 RT_DebugF: RecordsMax   = 29020045 ($1BACF8D)
00000025    41.88851547 RT_DebugF: Fields       = 5
00000026    41.88890457 RT_DebugF:    0 ) Type = 0(  Bool) Size = 1
00000027    41.88928223 RT_DebugF:    1 ) Type = 1(   Int) Size = 4
00000028    41.88965988 RT_DebugF:    2 ) Type = 2( Float) Size = 4
00000029    41.89003372 RT_DebugF:    3 ) Type = 3(String) Size = 64
00000030    41.89041138 RT_DebugF:    4 ) Type = 4(   Bin) Size = 1
00000031    41.89050674 RT_DebugF: ALL DONE

[Forensic]

#StainlessS: My script finds the average luminosity differential by analyzing every adjacent pixel pair within the first video frame, with an option to only process every other 2x2 horizontal and vertical block to ensure any slice (e.g. h.264, h.265) boundaries are excluded. My script does not accept a frame range, assuming that the user will decide which frame to send to the function with each call (as only the first frame is processed). By calling this function before and again after a given filter, this script quantifies a filter's affect on luminosity contrast. NOTE: The perimeter pixels are intentionally ignored as they often incur higher quantization errors.
I use this dozens of times with every video enhancement. The problem is that my AviSynth script is sooooo slow due to the thousands of RT_YDifference calls. Unfortunately, it may be months before I can successfully write and compile a valid AviSynth CPP file. Would you consider adding this capability to RT_Stats?

Function AvgLumaDif(Clip Clip, bool "slices") {
 GScript("""
  slices = default(slices, false)
  current_frame=0
  value=float(0)
  count=float(0)
  step=1
  if (slices) {step=4}
  for (y=1,Clip.height-step,step) { for (x=1,Clip.width-step,step) {
   Try {
    value=value+RT_YDifference(Clip, delta=0, x=x, y=y, w=1, h=1, x2=x+1, y2=y)+RT_YDifference(Clip, delta=0, x=x, y=y, w=1, h=1, x2=x, y2=y+1)
    \+RT_YDifference(Clip, delta=0, x=x+1, y=y, w=1, h=1, x2=x+1, y2=y+1)+RT_YDifference(Clip, delta=0, x=x, y=y+1, w=1, h=1, x2=x+1, y2=y+1) 
    count=count+1
   }
   Catch (err) {}
  } }
  if (count>0) {value=value/(4*count)}
  return value
 """)
}

[StainlessS]

Forensic, give me a couple of days and I see what I can do.

[Forensic]

I appreciate the consideration.

[StainlessS]

Originally Posted by Forensic

Function AvgLumaDif(Clip Clip, bool "slices") {
 GScript("""
  slices = default(slices, false)
  current_frame=0
  value=float(0)
  count=float(0)
  step=1
  if (slices) {step=4}
  for (y=1,Clip.height-step,step) { for (x=1,Clip.width-step,step) {
   Try {
    value=value+RT_YDifference(Clip, delta=0, x=x, y=y, w=1, h=1, x2=x+1, y2=y)+RT_YDifference(Clip, delta=0, x=x, y=y, w=1, h=1, x2=x, y2=y+1)
    \+RT_YDifference(Clip, delta=0, x=x+1, y=y, w=1, h=1, x2=x+1, y2=y+1)+RT_YDifference(Clip, delta=0, x=x, y=y+1, w=1, h=1, x2=x+1, y2=y+1) 
    count=count+1
   }
   Catch (err) {}
  } }
  if (count>0) {value=value/(4*count)}
  return value
 """)
}

Have so far modified above to this (untested)

Function AvgLumaDif(Clip Clip, bool "slices", int "n") {
    GScript("""
        step= (Defined(slices) && slices) ? 4 : 1
        n   = Default(n,0)      # default current_frame = 0
        value=0.0   count=0.0
        for (y=1,Clip.height-step,step) {
            for (x=1,Clip.width-step,step) {
                Try {
                    value=value
                        \ + RT_YDifference(Clip,n,delta=0,x=x,  y=y,   w=1, h=1, x2=x+1, y2=y)
                        \ + RT_YDifference(Clip,n,delta=0,x=x,  y=y,   w=1, h=1, x2=x,   y2=y+1)
                        \ + RT_YDifference(Clip,n,delta=0,x=x+1,y=y,   w=1, h=1, x2=x+1, y2=y+1)
                        \ + RT_YDifference(Clip,n,delta=0,x=x,  y=y+1, w=1, h=1, x2=x+1, y2=y+1)
                    count=count+1
                } Catch (err) {}
            }
        }
        if (count>0) {value=value/(4*count)}
        return value
    """)
}

Can you clarify your intention as it don't seem right to me.
With step=1, the 2x2 pixel blocks overlap, with step=4, you only process one 2x2 pixel block out of every 4.
If intention is to process every 2x2 pixel block once only, then see no alternative to step=2, skipping 2 pixel
perimeter if slice=true, skip 1 pixel perimeter if slice=false (with little difference from slice=true except blocks
are offset x,y by 1 pixel).

EDIT: Perhaps something like this (modified from above described, anticipating required intention):

Function AvgLumaDif(Clip Clip, bool "slices", int "n") {
    Clip
    perimeter = (Defined(slices) && slices) ? 4 : 2           # EDIT: Or perhaps 2:1
    n   = Default(n,0)      # default current_frame = 0
    value=0.0
    GScript("""
        for (y=perimeter,Height-(2+perimeter),2) {
            for (x=perimeter,Width-(2+perimeter),2) {
                value=value
                    \ + RT_YDifference(Clip,n,delta=0,x=x,  y=y,   w=1, h=1, x2=x+1, y2=y)
                    \ + RT_YDifference(Clip,n,delta=0,x=x,  y=y,   w=1, h=1, x2=x,   y2=y+1)
                    \ + RT_YDifference(Clip,n,delta=0,x=x+1,y=y,   w=1, h=1, x2=x+1, y2=y+1)
                    \ + RT_YDifference(Clip,n,delta=0,x=x,  y=y+1, w=1, h=1, x2=x+1, y2=y+1)
            }
        }
        count = ((Width / 2) - perimeter) * ((Height / 2) - perimeter)
        if (count>0) {value=value/(4*count)}
    """)
    return value
}

EDITED:UNTESTED

EDIT: are RGB and YUY2 colorspaces required ? (RGB -> YUV_Y)

[Forensic]

Yes, the intention is for all the 2x2 blocks to overlap when Slices is set to false (thus step = 1). In that way, every possible horizontal and vertical pixel pair gets evaluated. When Slices is true, only 1/16th as many pixels pairs will be tested, but that is to ensure all tested pixels are always at least one pixel away from slice boundaries (which can occur at nearly any multiple of every four pixels under h.265, as I understand it). This is important because perimeter pixels, occurring at either the entire video boundary or the boundaries between slices, can disproportionally represent any contrast changes as a result of the compression's disproportional quantization errors spanning those boundaries.

Your first rewrite of my script is functionally identical to mine, except that you added "n" so a specific frame can be called rather than inferred. EITHER WAY, THIS IS WHAT I INTENDED. The second rewrite "Perhaps something like this (modified from above described, anticipating required intention)" is less suitable as it unnecessarily skips 75% of the available pixel pairs, and thus is less accurate, albeit marginally. I would only want that if, even as a DLL, functionality is far too slow otherwise.

BTW: I have to include "current_frame=0" for my script to work on my primary computer. However, that is a mute point once this script becomes a DLL.

[StainlessS]

unnecessarily skips 75% of the available pixel pairs

Rather than duplicating comparisons nearly all of the time, ie non duplicating only around edges with perimeter with remainder comparisons all done twice,
that what you mean ?

When Slices is true, only 1/16th as many pixels pairs will be tested, but that is to ensure all tested pixels are always at least one pixel away from slice boundaries

In that case would would not perimeter be required to be 5, step = 4 ?

0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000111111111111
00001xx11xx11xx1
00001xx11xx11xx1
0000111111111111

x's being when slice = true, 1's being slice boundaries,0's being perimeter.

EDIT: Or rather, perimeter = 4, start pos = perimeter + 1 (perimeter = (slice=true) ? 4 : 0)

EDIT: Arh forget what I said, I was thinking you wanted perimeter around edge of frame, and now also around each slice, I understand now.

[Forensic]

Just to be sure we are on the same page.

x= process, -=don't process

      slice=false                  slice=true
------------------------    ------------------------
-xxxxxxxxxxxxxxxxxxxxxx-    -xx--xx--xx--xx--xx--xx-
-xxxxxxxxxxxxxxxxxxxxxx-    -xx--xx--xx--xx--xx--xx-
-xxxxxxxxxxxxxxxxxxxxxx-    ------------------------
-xxxxxxxxxxxxxxxxxxxxxx-    ------------------------
-xxxxxxxxxxxxxxxxxxxxxx-    -xx--xx--xx--xx--xx--xx-
-xxxxxxxxxxxxxxxxxxxxxx-    -xx--xx--xx--xx--xx--xx-
-xxxxxxxxxxxxxxxxxxxxxx-    ------------------------
-xxxxxxxxxxxxxxxxxxxxxx-    ------------------------
-xxxxxxxxxxxxxxxxxxxxxx-    -xx--xx--xx--xx--xx--xx-
-xxxxxxxxxxxxxxxxxxxxxx-    -xx--xx--xx--xx--xx--xx-
------------------------    ------------------------

[Gavino]

Originally Posted by Forensic

I have to include "current_frame=0" for my script to work on my primary computer.

That's because, if 'n' is not specified to RT_YDifference, it defaults to the value of current_frame. Since your function is called at compile time, current_frame does not exist unless you set it yourself. In StainlessS's version of the function, 'n' is specified, so current_frame is irrelevant.

[Forensic]

Thank you. That makes sense.

[StainlessS]

Forensic
Find below, 1) equivalent to original func, 2) modified using similar-ish logic, 3) suggested implementation,
if OK will probably start coding tomorrow, (pub is calling to me ).

EDIT: If not OK, then need to know how you want Odds & Ends dealt with.

Still want to know, is YUY2 and RGB (RGB -> YUV_Y) required ? *** FORGET THIS QUESTION ***

Function AvgLumaDif(Clip c, bool "slices", int "n") { # Equivalent to Original
    c
    step= (Defined(slices) && slices) ? 4 : 1
    n   = Default(n,0)      # default current_frame = 0
    value=0.0   count=0
    GScript("""
        for (y=1,Height-step,step) {
            for (x=1,Width-step,step) {
                Try {
                    value=value
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y,   x2=x+1, y2=y,   w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y,   x2=x,   y2=y+1, w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x+1, y=y,   x2=x+1, y2=y+1, w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y+1, x2=x+1, y2=y+1, w=1, h=1)
                    count=count+1
                } Catch (err) {}
            }
        }
        if (count>0) {value=value/(4*count)}
    """)
    return value
}

Function AvgLumaDif_2(Clip c, bool "slices", int "n") {     # Same logic, Modifed to remove nonsense eg width-step for limit
    c
    step= (Defined(slices) && slices) ? 4 : 1
    n   = Default(n,0)      # default current_frame = 0
    W = (Width  / 4) * 4        # Ignore RHS odds and ends, FULL 4x4 pixel blocks only
    H = (Height / 4) * 4        #
    value=0.0   count=0
    GScript("""
        for (y=1,H-3,step) {
            for (x=1,W-3,step) {
                Try {
                    value=value
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y,   x2=x+1, y2=y,   w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y,   x2=x,   y2=y+1, w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x+1, y=y,   x2=x+1, y2=y+1, w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y+1, x2=x+1, y2=y+1, w=1, h=1)
                    count=count+1
                } Catch (err) {}
            }
        }
        if (count>0) {value=value/(4*count)}
    """)
    return value
}

Function AvgLumaDif_MOD(Clip c, bool "slices", int "n") {   # Suggested implementation, same result as modified logic above
    c
    step = (Defined(slices) && slices) ? 4 : 1
    n = Default(n,0)            # default current_frame = 0
    W = (Width  / 4) * 4        # Ignore RHS odds and ends, FULL 4x4 pixel blocks only
    H = (Height / 4) * 4        #
    Assert(W>0 && H>0,"AvgLumaDif_MOD: Illegal Frame Size")
    value=0.0
    GScript("""
        for (y=1,H-3,step) {
            for (x=1,W-3,step) {
                value=value
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y,   x2=x+1, y2=y,   w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y,   x2=x,   y2=y+1, w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x+1, y=y,   x2=x+1, y2=y+1, w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y+1, x2=x+1, y2=y+1, w=1, h=1)
            }
        }
        count = (step==1) ? ((W-3) * (H-3)) : (W * H)
        value = value / (4*count)
    """)
    return value
}

W=512+3
ColorBars(width=W,height=64)
A=AvgLumaDif()
B=AvgLumaDif_2()
C=AvgLumaDif_MOD()
RT_DebugF("%f %f %f",A,B,C)
RT_SubTitle("%f %f %f",A,B,C)

EDIT: I'll try to comment source so you can understand and include in your own functions dll.
EDIT: Although it will not use RT_ funcs, will read frame data directly so will not be too similar to script (speed),
forget previous question on YUY2 and RGB, I shall implement for those too as it may assist for future projects.

[Forensic]

I see a minor math error when slices is TRUE (see below)

Function AvgLumaDif_MOD(Clip c, bool "slices", int "n") {   # Suggested implementation, same result as modified logic above
    c
    step = (Defined(slices) && slices) ? 4 : 1
    n = Default(n,0)            # default current_frame = 0
    W = (Width  / 4) * 4        # Ignore RHS odds and ends, FULL 4x4 pixel blocks only
    H = (Height / 4) * 4        #
    Assert(W>0 && H>0,"AvgLumaDif_MOD: Illegal Frame Size")
    value=0.0
    GScript("""
        for (y=1,H-3,step) {
            for (x=1,W-3,step) {
                value=value
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y,   x2=x+1, y2=y,   w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y,   x2=x,   y2=y+1, w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x+1, y=y,   x2=x+1, y2=y+1, w=1, h=1)
                    \ + RT_YDifference(c,n,delta=0, x=x,   y=y+1, x2=x+1, y2=y+1, w=1, h=1)
            }
        }
        count = (step==1) ? ((W-3) * (H-3)) : (W * H /16)
        value = value / (4*count)
    """)
    return value
}

[StainlessS]

yes of course u r correct. that error would not have escaped notice on implemented plug. I should have used w/4 * h/4.

[Forensic]

StainlessS: "slices" should default to false and the final script does not denote that. Does the boolean naturally default to false when a state is not specified?

DOCUMENTATION: AvgLumaDif returns the average of all pixel pair differentials for a given frame "n" (default=0) ignoring perimeter pixels and, when optional "slices" is true (default=false), all 4x4 pixel block boundaries are treated as perimeter pixels.

[StainlessS]

F, ( perhaps I should have answered in PM, where I think the question originated)

step = (Defined(slices) && slices) ? 4 : 1

The logic there does all that you desire (well maybe not all but all you could expect).

Defined(Slices) is a boolean also Slices is a Boolean.
Result of two Booleans is a Boolean.
If Defined(Slices) aint true, then Slices dont matter at all.. (under condition && condition)

More on what you require, step is only 4, if Slices is both Defined, and True, Else step is 1. but am not
altogether above mistakes, could have it altogether back to front. ( been suffering from a 'sort' of illness of late
we who suffer from it know it as L.O.A., "lack of alcohol"), really bad thing to get. (Not terminal, just feels like it is).