BrainModular

Code: Select all

///////////////////////////////////////////////////////////////////////////////
// Function: Removes any zero values from an array 
// Version : 1.0
// Date : 12 June 2012
//////////////////////////////////////////////////////////////////////////////
// variables declaration
Var ArrayIn, ArrayOut : tparameter;
Var non_zero, i, j : integer;
// initialisation : create parameters
procedure init;
begin  
	ArrayIn:= createParam('Array in', PtArray); 
	SetIsOutput(ArrayIn,false);
	ArrayOut:= createParam('Array out', PtArray);         
	SetIsInput(ArrayOut,false);
end;

// Callback procedure
Procedure Callback(N:integer); 
begin
	if (N=ArrayIn)  then begin
		non_zero := 0;
		i := 0;
		j := 0;
		//count non-zero elements
		for i:= 0 to GetLength(ArrayIn)-1 do begin
			If  GetDataArrayValue&#40;ArrayIn, i&#41;  <> 0  then begin
				non_zero &#58;= non_zero + 1;
			 end;
		end;	
		//set output array to size of non zero elements
		SetLength&#40;ArrayOut, non_zero&#41;;
		//copy only non_zero elements to output
		for i&#58;= 0 to GetLength&#40;ArrayIn&#41;-1  do begin
			If  GetDataArrayValue&#40;ArrayIn, i&#41;  <> 0  then begin
				SetDataArrayValue&#40;ArrayOut, j, GetDataArrayValue&#40;ArrayIn, i&#41;&#41;; 
				j &#58;= j + 1;
			end;
		end;	
	end;
end;
//////////////////////////////
// main proc
//////////////////////////////
Procedure Process;
begin

end;

Code: Select all

Var ArrayIn, ArrayOut : tparameter;
// initialisation : create parameters
procedure init;
begin  
    ArrayIn:= createParam('Array in', PtArray); 
    SetIsOutput(ArrayIn,false);
    ArrayOut:= createParam('Array out', PtArray);         
    SetIsInput(ArrayOut,false);
end;

// Callback procedure
Procedure Callback(N:integer); 
  Var i, j : Integer;
begin
    if (N=ArrayIn)  then begin
        j := 0;
        for i:= 0 to GetLength(ArrayIn)-1 do begin
            If &#40;GetDataArrayValue&#40;ArrayIn, i&#41;  <> 0&#41; then begin
               SetDataArrayValue&#40;ArrayOut, j, GetDataArrayValue&#40;ArrayIn, i&#41;&#41;;
               j &#58;= j + 1;
            end;
        end;    
        SetLength&#40;ArrayOut, j&#41;;
    end;
end;

Code: Select all

////////////////////////////////////////////////////////////////////////////////
// ArrayFind.script
// Returns the array index where array B is first found in array A, with an
// optional start index for array A. If no matches, the result is -1.
//
// The returned index in A is the "real" index; the start offset is not 
// subtracted from the result.
//
// bSork, V2 June 2012
////////////////////////////////////////////////////////////////////////////////

VAR pArrA, pStartA, pArrB, pResult : tParameter;

PROCEDURE Init;
BEGIN
   pArrA := CreateParam('array A', ptArray); SetIsOutput(pArrA, FALSE);
   SetMin(pArrA, -1000000000);    SetMax(pArrA, +1000000000);

   pStartA := CreateParam('start index A', ptDataFader); SetIsOutput(pStartA, FALSE);
   SetMin(pStartA, 0); SetMax(pStartA, 8191); SetFormat(pStartA, '%.0f');
   SetDefaultValue(pStartA, 0);

   pArrB := CreateParam('array B', ptArray); SetIsOutput(pArrB, FALSE);
   SetMin(pArrB, -1000000000);    SetMax(pArrB, +1000000000);

   pResult := CreateParam('result', ptDataField); SetIsInput(pResult, FALSE);
   SetMin(pResult, -1); SetMax(pResult, 8191); SetFormat(pResult, '%.0f');
   SetValue(pResult, 0);
END; // Init

PROCEDURE Find;
   VAR lenA, lenB : Integer;
   VAR r, a, a2, b : Integer;
   VAR bx : Single;
   VAR found : Boolean;
BEGIN
   r := -1;
   lenB := GetLength(pArrB);
   IF (lenB > 0) THEN BEGIN
      b := 0;
      bx := GetDataArrayValue(pArrB, b);
      a := round(GetValue(pStartA));
      lenA := GetLength(pArrA);
      WHILE ((r = -1) AND ((lenA - a) >= lenB)) DO BEGIN
         found := (bx = GetDataArrayValue(pArrA, a));
         IF (found) THEN BEGIN
            a2 := a + 1;
            b := 1;
         END;
         WHILE &#40;found AND &#40;b < lenB&#41;&#41; DO BEGIN
            found &#58;= &#40;GetDataArrayValue&#40;pArrA, a2&#41; = GetDataArrayValue&#40;pArrB, b&#41;&#41;;
            a2 &#58;= a2 + 1;
            b &#58;= b + 1;
         END;
         IF &#40;found AND &#40;b = lenB&#41;&#41; THEN
            r &#58;= a
         ELSE
            b &#58;= 0;
         a &#58;= a + 1;
      END;
   END;
   SetValue&#40;pResult, r&#41;;
END; // Find

PROCEDURE Callback&#40;n &#58; Integer&#41;;
BEGIN
   IF &#40;n <= pArrB&#41; THEN
      Find;
END; // Callback

Code: Select all

var input   : Tparameter;
var output  : Tparameter;
var transpo : TParameter;
var voices  : TParameter;

procedure init;
begin  
 Input := CreateParam('In',ptMidi);
 Output := CreateParam('Out',ptMidi);
 transpo := CreateParam('transpo',ptDataFader);
 voices := CreateParam('voices',ptDatafield);

 SetIsInput(Output,false);
 SetIsOutPut(Input,false);
 SetIsOutPut(transpo,false);
 SetFormat(transpo,'%.0f');
 SetIsInput(voices,false);
 SetMin(transpo,-24);
 SetMax(transpo,24);

end;

var i            : integer;
var nbOfMidi     : integer;
var ReceivedMidi : TMidi;
var TranspoVal   : single;

//////////////////////////////
// main proc
//////////////////////////////
procedure Process;
begin
 nbOfMidi := GetLength(input);  // get the number of incoming midi codes 
 if nbOfMidi > 0 
 then begin
    SetLength(outPut,nbOfMidi);      // set the number of output codes
    transpoVal := getValue(transpo); // get the transpo value
    for i := 0 to nbOfMidi-1         // loop for all input codes, for polyphonic data (chords)
    do begin
      GetMidiArrayValue(input,i,ReceivedMidi); // get each code
      ReceivedMidi.data1 := ReceivedMidi.data1+trunc(transpoVal); // calculate transpo
      SetMidiArrayValue(output,i,ReceivedMidi); // set output value     
    end;
 end 
 else SetLength(outPut,0); // nothing received, set out length to 0
end;

Code: Select all

SetValue(voices, nbOfMidi );

Code: Select all

CONST BUFFER_SIZE = 128;

// MIDI channel messages
CONST NOTEOFF = Byte(128);
CONST NOTEON  = Byte(144);

TYPE tMidiArr = ARRAY OF tMidi;

TYPE tNoteOns = RECORD
        origChannel : Byte;
        origNoteNo  : Byte;
        outChannel  : Byte;
        outNoteNo   : Byte;
     END;

VAR pMidiIn, pMidiOut1 : tParameter;
VAR pTranspose, pNumNotes : tParameter;

VAR sentNoteOns : ARRAY OF tNoteOns;
VAR numIn, numSentNoteOns, numOut1 : Integer;
VAR transpose : Integer;

PROCEDURE Init;
   VAR i : Integer;
BEGIN
   pMidiIn := CreateParam('midi in', ptMidi); SetIsOutput(pMidiIn, FALSE);
   pMidiOut1 := CreateParam('midi out', ptMidi); SetIsInput(pMidiOut1, FALSE);

   pTranspose := CreateParam('transpose', ptDataFader); SetIsOutput(pTranspose, FALSE);
   SetMin(pTranspose, -48); SetMax(pTranspose, 48);
   SetFormat(pTranspose, '%.0f'); SetSymbol(pTranspose, 'sm');

   pNumNotes := CreateParam('num notes', ptDataField); SetIsInput(pNumNotes, FALSE);

   SetArrayLength(sentNoteOns, BUFFER_SIZE);

   numSentNoteOns := 0;
   numOut1 := 0;
END; // Init

FUNCTION IsNoteOn (currMsg : tMidi) : Boolean;
BEGIN
   IsNoteOn := ((currMsg.msg = NOTEON) AND (currMsg.data2 > 0));
END;

FUNCTION IsNoteOff (currMsg : tMidi) : Boolean;
BEGIN
   IsNoteOff := (currMsg.msg = NOTEOFF) OR ((currMsg.msg = NOTEON) AND (currMsg.data2 = 0));
END;

PROCEDURE CreateOut(currMsg : tMidi);
BEGIN
   SetMidiArrayValue(pMidiOut1, numOut1, currMsg);
   numOut1 := numOut1 + 1;
END; // CreateOut

PROCEDURE CreateNoteOnOut(origMsg, outMsg : tMidi);
   VAR curr : tNoteOns;
BEGIN
   WITH curr DO BEGIN
      origChannel := origMsg.channel;
      origNoteNo  := origMsg.data1;
      outChannel  := outMsg.channel;
      outNoteNo   := outMsg.data1;
   END;
   sentNoteOns[numSentNoteOns] := curr;
   numSentNoteOns := numSentNoteOns + 1;
   CreateOut(outMsg);
END; // CreateNoteOnOut

PROCEDURE CheckSendNoteOff(currMsg : tMidi);
   VAR i, j : Integer;
   VAR outMsg : tMidi;
   VAR curr : tNoteOns;
BEGIN
   j := 0;
   FOR i := 0 TO (numSentNoteOns - 1) DO BEGIN
      curr := sentNoteOns[i];
      IF ((currMsg.channel = curr.origChannel) AND (currMsg.data1 = curr.origNoteNo)) THEN BEGIN
         outMsg.msg     := currMsg.msg;
         outMsg.channel := curr.outChannel;
         outMsg.data1   := curr.outNoteNo;
         outMsg.data2   := currMsg.data2;
         CreateOut(outMsg);
         j := j + 1;
      END
      ELSE BEGIN
         sentNoteOns[i - j] := curr;
      END;
   END;
   numSentNoteOns := numSentNoteOns - j;
END; // CheckSendNoteOff

PROCEDURE CheckInput(currMsg : tMidi);
   VAR newMsg : tMidi;
BEGIN
   newMsg := currMsg;
   IF (IsNoteOn(currMsg)) THEN BEGIN
      newMsg.data1 := newMsg.data1 + transpose;
      CreateNoteOnOut(currMsg, newMsg);
   END
   ELSE IF (IsNoteOff(currMsg)) THEN
      CheckSendNoteOff(currMsg);
   SetValue(pNumNotes, numSentNoteOns);
END; // CheckInput

PROCEDURE Callback(n : Integer);
BEGIN
   CASE n OF
      pMidiIn    : numIn     := GetLength(n);
      pTranspose : transpose := round(GetValue(n));
   END;
END; // Callback

PROCEDURE Process;
   VAR i : Integer;
   VAR currMsg : tMidi;
BEGIN
   FOR i := 0 TO (numIn - 1) DO BEGIN
      GetMidiArrayValue(pMidiIn, i, currMsg);
      CheckInput(currMsg);
   END;
   SetLength(pMidiOut1, numOut1);
   numOut1 := 0;
END; // Process