Automatische Aus- und Einblendprozedur

Hallo alle Skriptschreiber,

vielleicht möchtet Ihr auf einen Befehl oder ein Ereignis hin mal einen bestimmten Player herunter- und auch wieder aufblenden. Mit Hilfe einer aufzurufenden Prozedur kann das klappen:

procedure FadePlayerDown(PlaylistIndex: integer; PlayerIndex: integer;
  StartLevel: integer; TargetLevel: integer; FadeTime: integer);
var
  Step: integer;
begin
  if StartLevel <> TargetLevel then begin                                                // Achtpassen, daß Pegelwerte unterschiedlich, sonst ...*
    Step := trunc(FadeTime / (Abs(Abs(StartLevel) - Abs(TargetLevel))) * 1000);          // Schrittweite bestimmen
    repeat                                                                               // Schleife starten
      StartLevel := StartLevel - 1;
      ExecuteCommand('PLAYER ' + IntToStr(PlaylistIndex + 1) + '-' 
        + IntToStr(PlayerIndex + 1) + ' VOLUME ' + IntToStr(StartLevel));               // Player einpegeln
      Sleep(Step);                                                                       // entsprechend zuwarten, damit Fadezeit eingehalten wird
    until StartLevel = TargetLevel - 1;                                                  // Wenn Zielpegel erreicht, Schleife stoppen
  end
  else begin
    SystemLog('Fehler in Blendprozedur: Start- und Zielpegel müssen sich unterscheiden!');  // *... mecker, weil Division durch null
  end;
end;

Der Aufruf im Skript erfolgt folgendermaßen:

FadePlayerDown(PlaylistIndex (0-basiert), PlayerIndex (0-basiert), Startpegel [dBr], Zielpegel [dBr], Fadedauer [s]);

Ein Beispiel sähe so aus:

FadePlayerUp(0, 1, 0, -12, 3);

(„In der ersten Playlist den zweiten Player in drei Sekunden von null auf –12 dB regeln.“)

Der Pegel wird jeweils in Schritten von 1 dB verändert, und zwar mit solch zeitlichem Abstand, daß die Fadedauer eingehalten wird. Gleiche Werte für Start- und Zielpegel werden angemahnt. Damit der Pegel nicht ewig so niedrig bleibt, gibt’s auch eine Prozedur zum Aufblenden:

procedure FadePlayerUp(PlaylistIndex: integer; PlayerIndex: integer;
  StartLevel: integer; TargetLevel: integer; FadeTime: integer);
var
  Step: integer;
begin
  if StartLevel <> TargetLevel then begin                                               // Pegelwerte unterschiedlich, sonst ...*
    Step := trunc(FadeTime / (Abs(Abs(StartLevel) - Abs(TargetLevel))) * 1000);         // Schrittweite bestimmen
    repeat                                                                              // Schleife starten
      StartLevel := StartLevel + 1;
      ExecuteCommand('PLAYER ' + IntToStr(PlaylistIndex + 1) + '-' 
        + IntToStr(PlayerIndex + 1) + ' VOLUME ' + IntToStr(StartLevel));                // Player einpegeln
      Sleep(Step);                                                                       // entsprechend zuwarten, damit Fadezeit eingehalten wird
    until StartLevel = TargetLevel;                                                      // Wenn Zielpegel erreicht, Schleife stoppen
  end
  else begin
    SystemLog('Fehler in Blendprozedur: Start- und Zielpegel müssen sich unterscheiden!');  // *... mecker, weil Division durch null
  end;
end;

Deren Aufruf erfolgt sinngemäß mit

FadePlayerUp(…);

Ach ja, die Schleife ist eine andere als die, die ich schon mal erklärt habe. Man benötigt hier keine eigene Zählvariable, es wird eine Anweisung bzw. Kette von Anweisungen so oft ausgeführt („repeat“), bis eine bestimmte Bedingung („until …“) erfüllt ist. Im Gegensatz zur for … do-Schleife kann man sich begin und end; hier sparen.

repeat
   // Eine Reihe von Anweisungen
until <Bedingung für Ende der Schleife. Wenn "true", dann Stop.>;

Das ist an und für sich recht praktisch, man muß nur sicherstellen, daß besagte Endbedingung tatsächlich irgendwann mal erfüllt wird, sonst hängt sich das Programm in einer Schleife auf. Aber dafür gibt’s dann ja den Task-Manager.

Gedämpfte Grüße

TSD