1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

{------auslesen des Arrays und umwandel in Dezimalzahl---}

 zhler:= 0;
 a[0]:= $87;
 a[1]:= $40;
 a[2]:= 0;
 DezimalValue:= 0;
 
repeat
    ByteValue:= a[zhler];
    Inc(zhler);
    DezimalValue:= ((DezimalValue shl 7) + (ByteValue and $7f));
until (ByteValue and $80 = 0);					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

{-----DezimalZahl zurück ins Array-------}

a[0]:= 0;//<--$87
a[1]:= 0;//<--$40
a[2]:= 0;

zhler:= 0;

r:= DezimalValue;
repeat
  b:= (r shr 7) + (r and $7f);//(r and $80)
  a[zhler]:= (b);
  inc(zhler);
  r:= (r shr 7);

 until b = 0;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

var
  x: Cardinal;
  a: array[0..3] of Byte;

x := $12345678;
// Dinge tun, so dass -->
a[0] = $78;
a[1] = $56;
a[2] = $34;
a[3] = $12;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

  type
    TIntAsByte = record case boolean of
      FALSE: (asByte: array[0..3] of Byte);
      TRUE: (asInt: Integer);
    end;
  var
    x: TIntAsByte;
begin
  x.asInt := $12345678;
  ShowMessage(IntToHex(x.asByte[0],2));
  ShowMessage(IntToHex(x.asByte[1],2));
  ShowMessage(IntToHex(x.asByte[2],2));
  ShowMessage(IntToHex(x.asByte[3],2));					

1:
2:
3:
4:
5:
6:
7:
8:

 b:= (r shr 7) + (r and $80);//<--- b = $87
 a[zhler]:= b;
 inc(zhler);
....  //<-- aber wie weiter???

//oder
b := (r and $7f);//<--- b = $40
....//<-- aber wie weiter ,(r := r shr 7) muss ja auch noch rein					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

  var
    Value: Integer;
    b: Byte;
begin
  Value := $12345678;
  repeat
    b := Value and $7f;
    Value := Value shr 7;
    if (Value > 0) then
      b := b or $80;
    Memo1.Lines.Add(IntToHex(b,2));
  until b = 0;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

type
  TForm1 = class(TForm)
    meLog: TMemo;
    edValue: TEdit;
    btnStart: TButton;

// http://cs.fit.edu/~ryan/cse4051/projects/midi/midi.html#vlq
procedure TForm1.btnStartClick(Sender: TObject);
  var
    Value: Cardinal;
    Size, i: Integer;
    bytes: array[0..3] of Byte;
begin
  meLog.Clear;
  Value := StrToIntDef(edValue.Text,0); // Wert aus der GUI holen
  if (Value = 0) then begin // Trivialfall 0 ausschließen
    meLog.Lines.Add('$00');
    Exit;
  end;
  if (Value > $FFFFFFF) then // Zu große Werte auch ausschließen
    raise Exception.Create('Value exceeds MIDI constraints!');
  // Bereich OK, nach MIDI-Spec umwandeln
  i := Value;
  Size := 0; // rausfinden wieviele Bytes das gibt, weil wir rückwärts laufen müssen (MSB first!)
  while (i > 0) do begin
    i := i shr 7;
    Inc(Size);
  end;
  for i := Size-1 downto 0 do begin // vom LSB zum MSB
    bytes[i] := Value and $7f; // 7 Bit abspalten
    Value := Value shr 7;
    if (i <> Size-1) then // bei allen ausser dem letzten Wert Bit 7 setzen -> VLQ-Protokoll
      bytes[i] := bytes[i] or $80;
  end;
  for i := 0 to Size-1 do // Werte vom MSB zum LSB ausgeben
    meLog.Lines.Add('$'+IntToHex(bytes[i],2));					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

var
  MyArray: Array [0..4] of Byte;//<--dient nur zur Demo
  ArrayPos: integer;           //<--dient nur zur Demo 
  DezDeltaTime: integer;       //<--dient nur zur Demo

  HexMask: DWord;
  zhler: integer;
begin
{-- DezDeltatime ist die Zeit vor einem Event --}
{-- ArrayPos währe die aktuelle Position im Array --}
  DezDeltaTime:= 380160;//960 ist der Zeitwert 1/4Note, 380160 ist ein vielfaches davon ;
  ArrayPos:= 0; 
  
  zhler:= 0;
  
  HexMask:= ((DezDeltaTime and $7F);
  While DezDeltaTime > 0 do
  begin
     DezDeltaTime:= (DezDeltaTime shr 7);
     if DezDeltaTime <> 0 then
        HexMask:= (HexMask shl 8);
     
     HexMask:= HexMask or ((DezDeltaTime and $7F) or $80);
     inc(zhler);
  end;

{-- und nun den Hexwert in richtiger Reihenfolge ablegen --} 
  While zhler > 0 do
  begin
     MyArray[ArrayPos]:= LoWord(LoByte(HexMask));
     HexMask:= (HexMask shr 8);
     inc(ArrayPos);
     dec(zhler);
  end;
end;