dofigos PAL(SAM BROADCASTER)

var Str1 : string;                  // Declare a string variable to hold the data being written
var Song : TDataSet;                // Declare a container for the song

Song := queue.songlist;             // Assign the next track in the queue to the DataSet Song

// Concatenate the track artist and title into the string variable Str1
Str1 := Song['ARTIST']+' '+Song['TITLE'];

// Write the information to a temporary file
StrToFile('C:\Users\Mathew\Desktop\test.txt', Str1);

_________________________________________________________________

WriteLn('Hello world!'); 

----------------------------------------------------------------

{ This is a comment }
// This is another comment

_________________________________________________________________-

Información general:

PAL es la abreviatura de lista de reproducción de automatización Lengua y fue desarrollado para dar a los propietarios de estaciones pleno poder sobre su rotación música. El objetivo era que para nada una estación de lista de reproducción programador podría soñar para arriba - PAL sería capaz de lograrlo. Hoy miles de usuarios de SAM Broadcaster usan el poder de PAL para automatizar por completo las funciones principales de la estación, incluyendo el cambio de DJ, corriendo dos por Martes, noticias cada hora, jingles y anuncios programados precisos, e incluso la descarga de contenido en su rotación.
Esta guía tiene como objetivo enseñarle rápidamente los conceptos básicos de scripting PAL y proporcionar suficientes ejemplos del mundo real para empezar. Al principio scripting PAL podría parecer muy desalentadora para cualquier nuevo usuario, pero sólo seguir con ella durante un tiempo y enseguida se dará cuenta del poder que puede ejercer en la automatización de sus tareas diarias. Es sin duda vale la pena el sudor y las lágrimas después de haber superado la curva de aprendizaje inicial.

Cómo crear un script PAL:

Scripting PAL - Ejemplo "Hola Mundo"

Paso 1. En SAM Broadcaster ir a la opción de menú Menú-> Ventana-> guiones PAL y activar la ventana de instrucciones PAL.
Paso 2. Haga clic en el botón ("+") Add. Esto abrirá el diálogo de opciones de script.
Paso 3. Junto al archivo de origen de la escritura, haga clic en Examinar ("carpeta") botón situado a la derecha del campo de edición. Introduzca el nombre del script que desea cargar, o, si el guión no existe, el nombre de la secuencia de comandos para crear. Para este ejemplo, es "Guide.PAL". Haga clic en Aceptar. (Si se le pide para crear el archivo, seleccione sí ...)
Paso 4. La entrada guión Guide.PAL aparecerá dentro de la ventana Scripts PAL. Haga doble clic en la entrada Guide.PAL abrir el IDE PAL.
Paso 5. Dentro del IDE PAL escriba el texto siguiente:

WriteLn ('¡Hola, mundo! ");

Paso 6. Haga clic en el botón Ejecutar (o presione [F9]).
La línea azul muestra la línea que se está ejecutando, y la salida se escribe en el lado derecho de la IDE PAL. (Se mostrará "¡Hola, mundo!".) El estado de la secuencia de comandos en la barra de estado también se mostrará en el IDE PAL.
¡Felicitaciones! Usted sólo han entrado en el misterioso mundo de los scripts de automatización de radio!
El lenguaje de scripting PAL se basó en PASCAL, para ser más exactos, la versión de programación orientada a objetos de Pascal llama Delphi. Delphi es el potente lenguaje de programación orientado a objetos que se utilizó para desarrollar SAM Broadcaster. Así que sólo convenía a PAL base alrededor de este lenguaje de gran alcance.
La estructura básica de este idioma será explorada en secciones de seguir y formará los bloques básicos de nuestros scripts PAL más avanzada de construcción. Nota: Antes de continuar aquí usted ya debe saber cómo crear un script PAL en blanco. Vea la "scripting PAL: Hola ejemplo del mundo" por encima.

Comentarios

Los comentarios son de texto añadido a un script que está totalmente ignorado por el compilador. Esto se utiliza para proporcionar más información a cualquier espectador de la escritura humana para que sea más fácil de leer y entender la lógica de la secuencia de comandos.
PAL es compatible con dos estilos diferentes de comentarios:

{Esto es un comentario}
// Este es otro comentario

Ventana de salida

Durante el desarrollo de guiones PAL, se encuentra el IDE PAL muy útil. Se le muestra la línea exacta que se está ejecutando actualmente. Sin embargo, muchas veces lo que necesita saber lo que está pasando en el guión real. Desde el PAL IDE no admite la inspección variable que debe utilizar la técnica milenaria de escribir el actual estado de cosas a la ventana de salida.
Hay dos comandos simples para hacer esto:

WriteLn (Valor);
WriteStr (Valor);

La única diferencia entre los dos es que el comando WriteLn añadirá un carácter de nueva línea al final de la cadena, haciendo que la cadena a envolver en una nueva línea en la ventana de salida.

Comparar:

var T: Integer;
para T: = 1 a 3 hacer
WriteLn ('WriteLn' + IntToStr (T));

con

para T: = 1 a 3 hacer
WriteStr ('WriteStr' + IntToStr (T));

Variables y Constantes

Variables y constantes se utilizan para dar un nombre a un cierto valor de datos. Valores constantes no pueden cambiar durante el funcionamiento de la secuencia de comandos. Variables sin embargo se pueden cambiar en cualquier momento durante la secuencia de comandos. A diferencia de la mayoría de los idiomas, el nombre de la constante o variable no distingue entre mayúsculas y minúsculas. Por lo tanto a PAL MiVar y MiVar son la misma cosa.

Valores constantes se declaran como:

const MyConstValue = ConstValue;

Ejemplos:

const Val1 = 'Este es un valor de cadena ";
const Val2 = 1,234;
const Val3 = 1,234;
const Val4 = false;

Varibles se declara como:

MyVarName var: VARTYPE = valor por defecto;

E JEMPLOS:

var Val1: String = "Este es un valor de cadena";
var Val2: Integer = 1,234;
var Val3: Float = 1,234;
var Val4: String;

Como puede ver, un valor por defecto no se requiere para las variables, pero se recomienda utilizar uno que sea posible. El lenguaje PAL soporta todos los tipos de variables como la cadena, entero, flotante, booleano, variante y de fecha y hora. Las variables también puede ser arrays y objetos. Las variables pueden obtener un nuevo valor durante la vida de un guión. Veamos este ejemplo:

var S: Integer = 0;
PAL.Loop: = true;

WriteLn (S);
S: S = + 1;

WriteLn (S);
S: = 123;

WriteLn (S);
PAL.WaitForTime ('+ 00:00:10');

En el ejemplo anterior, el valor inicial de S es cero (0), y luego el valor se establece en S + 1, que es 1 + 1 = 2. Por último, S se establece en 123, y luego esperar durante 10 segundos antes de que se reinicie el guión.
Cada vez que el guión se reinicia, se borran las variables. Así S tendrá el valor de 0 de nuevo una vez que el guión se reinicia.

Mates

Matemáticas número entero básico

var m: número entero;
{Nota: una habitación de abajo son tanto de tipo entero}
m: = a + b;
m: = a - b;
m: = a * b;
m: = a div b; {Solo Integer; Los descartes resto}
m: = a mod b; Entero solamente; Sólo resta}
m: = -m;

Matemáticas flotador básico

var m: flotar;
{Nota: a & b a continuación puede ser de tipo entero o float}
m: = a + b;
m: = a - b;
m: = a * b;
m: = a / b; {Float única}
m: = -m;

Otras funciones matemáticas disponibles

m: = Ronda (1,2345); {Redondea el valor al valor entero más cercano)
m: = aleatoria; {Devuelve el valor de punto flotante aleatoria}

Sin funcionar (a: Float): Flotante;
función Sinh (a: Float): Flotante;
funcionar Cos (a: Float): Flotante;
funcionar Cosh (a: Float): Flotante;
Tan función (a: Float): Flotante;
función Tanh (a: Float): Flotante;
arcsin función (a: Float): Flotante;
funcionar arcsinh (a: Float): Flotante;
ArcCos función (un: Float): flotador;
función ArcCosh (a: Float): Flotante;
funcionar ArcTan (a: Float): Flotante;
funcionar arctanh (a: Float): Flotante;
funcionar Cotán (a: Float): Flotante;
función Hypot (x: Float; y: Float): Flotante;
funcionar Inc (var a: Integer; b: Entero): Flotante;
Abs función (a: Float): Flotante;
función Exp (a: Float): Flotante;
Ln función (a: Float): Flotante;
función Log2 (a: Float): Flotante;
funcionar Log10 (a: Float): Flotante;
función LogN de (n: Float; x: Float): Flotante;
función sqrt (v: Float): Flotante;
función Sqr (v: Float): Flotante;
Int función (v: Float): Flotante;
función Frac (v: Float): Flotante;
funcionar Tronco (v: Float): Flotante;
función Round (v: Float): Flotante;
la función de energía (base: Float; exponente: Float): Float;
función degtorad (v: Float): Flotante;
funcionar RadToDeg (v: Float): Flotante;
función Max (v1: Float; v2: Float): Float;
funcionar Min (v1: Float; v2: Float): Flotante;
función Pi: Float;
funcionar aleatoria: Float;
función randomInt (Rango: Entero): Entero;
procedimiento Randomize;
funcionar RandG (media: Float; stdDev: Float): Flotante;
función RandSeed: Integer;
SetRandSeed función (Seed: Entero);

Manejo de cadenas

Manejo detallado de cadena es un poco más allá del alcance de este documento, pero vamos a introducir algunas técnicas básicas rápidamente.

Var S1: String = "Esta es mi primera cadena ';
Var S2: String = "Otra cadena ';
Var I: Integer;
S2: = S1; {Copiar una cadena}
S2: = S1 + 'y que las rocas'; {Combinar cadenas}
S2: = Copy (S1,2,3); {Copie sólo ciertos caracteres en una cadena. (Copie 3 caracteres, comenzando en la posición 2)
WriteLn (S2);
I: = Longitud (S2); {Set I del número de caracteres que contiene S2}
I: = Pos ("mi", S1); {Encuentra el índice del primer partido}

Otras funciones de cadena disponibles

función IntToStr (v: Entero): String;
función StrToInt (str: String): Integer;
funcionar StrToIntDef (str: String; Def: Entero): Entero;
funcionar inttohex (v: Integer; Dígitos: Entero): Entero;
funcionar FloatToStr (v: Float): String;
funcionar StrToFloat (str: String): Flotante;
función StrToFloatDef (str: String; Def: Float): Flotante;
función Chr (x: Entero): String;
función Ord (s: String): String;
función charAt (s: String; x: Entero): String;
setCharAt procedimiento (var S: String; x: Integer; c: String);
procedimiento de Eliminar (var S: String; Índice: Integer; Len: Entero);
procedimiento Insert (src: String; var Dest: String; Índice: Entero);
funcionar en minúsculas (Str: String): String;
función AnsiLowerCase (Str: String): String;
funcionar mayúsculas (Str: String): String;
función AnsiUpperCase (Str: String): String;
funcionar Pos (substr: String; Str: string): Integer;
función de longitud (Str: String): Integer;
funcionar TrimLeft (Str: String): String;
función TrimRight (Str: String): String;
la función Trim (Str: String): String;
funcionar CompareText (Str1: String; Str2: String): Integer;
función AnsiCompareText (Str1: String; Str2: String): Integer;
funcionar CompareStr (Str1: String; Str2: String): Integer;
funcionar AnsiCompareStr (Str1: String; Str2: String): Integer;
IsDelimiter función (delims: String; s: String; Índice: Entero): Boolean;
LastDelimiter función (delims: String; s: String): Boolean;
funcionar QuotedStr (Str: String): String;

Tiempo de envases

Para las estaciones de radio de tiempo suele ser muy importante. PAL contiene una gran cantidad de características que ayuda a los programadores para hacer frente a tiempo.
El tipo de variable tiempo básico es DateTime

var D: DateTime;

Con este formato de la fecha y la hora se representa como un valor de punto flotante. La parte integral de un valor DateTime es el número de días que han pasado desde 12/30/1899. La parte fraccionaria de un valor DateTime es la fracción de un día de 24 horas que ha transcurrido.
Los siguientes son algunos ejemplos de valores DateTime y sus correspondientes fechas y horarios:
0 12/30/1899 12:00a.m.
2.75 01.01.1900 18:00
-1,25 12/29/1899 06 a.m.
35065 01/01/1996 12:00a.m.

Declaraciones Ejemplo:

D: = Now; {Fecha actual / hora}
D: = Fecha; {Hoy en día, con la parte de la fracción 0}
D: = Tiempo; {Solo el tiempo, la parte integral es 0}
D: = ahora - 1; {Ayer, esta vez exacta}
D: = ahora + (1/24); {Una hora a partir de este momento}

PAL también tiene una función de fecha máscara muy útil llamado TimeMask.
La propiedad TimeMask se utiliza para generar un valor DateTime y puede estar en varios formatos:
Tiempo estándar
HH: MM: SS
Máscara debe estar en formato de 24 horas y contiene todos los campos (HH, MM y SS - donde HH es hora, MM es minutos y SS es segundos)
Ejemplo
T ['14: 00: 00 '] generaría un valor DateTime exactamente 14:00 de hoy.

Cómputo de tiempo

+ HH: MM: SS
HH: MM: SS

Ejemplo:

T ['+ 00:00:30'] // genera un tiempo de exactamente 30 segundos a partir de la fecha y hora actuales.
T ['- 01:00:00'] // genera un tiempo de exactamente 1 hora antes.

La próxima vez (comodines)

XX: MM: SS
HH: XX: SS
HH: MM: XX

XX actúa como un comodín, donde la máscara a tratar de encontrar la próxima vez que cabe en la máscara.
Por ejemplo supongamos la hora actual es 14:05 y usamos XX: 00: 00 como nuestra máscara. La hora resultante será 15:00, ya que es el momento más cercano en el futuro que se adapte a la máscara con comodines.

La próxima vez (Fijo)
NEXTHOUR
NEXT60 Tanto devuelve el siguiente hora después de la hora actual. (Igual que el uso de las XX: 00: 00)

NEXTHALFHOUR
NEXT30 Tanto devuelve la siguiente media hora después de la hora actual.
Por ejemplo, si la hora actual es 14:15 a continuación, utilizando NEXT30 dará lugar a 14:30. Si el tiempo era 14:50, a continuación, utilizando NEXT30 volvería 15:00.

NEXTQUARTER
NEXT15 Ambos regresarán el próximo trimestre después de la hora actual. Por ejemplo el uso de la máscara NEXT15 a 14:05 volverá 14:15
Ejemplo propiedad TimeMask Escribe el resultado de ciertas máscaras vez a la ventana de salida.

WriteLn ('- Hora estándar');
WriteLn (T ['14: 00: 00 ']); {##} 14:00 de hoy
WriteLn (T ['04: 30: 00 ']); {## 04:30 AM hoy}
WriteLn (DateTime (T ['09: 00: 00 '] - 1)); {##} 09 a.m. AYER
WriteLn (DateTime (T ['09: 00: 00 '] + 1)); {##} MAÑANA 09 a.m.
WriteLn ('- Cálculo');
WriteLn (T ['+ 1:00:00']); {## Una hora a partir de este momento}
WriteLn (T ['- 00:00:30']); {##} 30 segundos hacia atrás
WriteLn (T ['NEXT60']); {##} Siguiente hora
WriteLn (T ['NEXT30']); {## Siguiente halfhour}
WriteLn (T ['NEXT15']); {##} Siguiente trimestre
WriteLn ('- comodines');
WriteLn (T ['XX: 00: 00']); {## Igual que Siguiente Hour}
WriteLn (T ['XX: 59: 30']); {## 30 segundos después de la siguiente minuto de la hora}
WriteLn (T ['XX: XX: 30']); {## Siguiente: 30 segundos}

Ejemplos:

D: = T ['13: 00: 00 ']; {13:00} hoy
D: = T ['+ 00:00:10']; {10 segundos a partir de ahora}
D: = 1 + T ['+ 00:00:10']; {Mañana, 10 segundos a partir de ahora}

Descifrando la fecha en sus múltiples partes:

var y, m, d: Integer;
hh var, mm, ss, ms: Integer;
var D: DateTime;

D: = Now;
DecodeDate (D, y, m, d);
DecodeTime (D, hh, mm, ss, ms);

Función DayOfWeek:
si DayOfWeek (ahora) = Domingo entonces {hacer cosas};

Los días de la semana se almacenan en valores constantes que puede utilizar. Domingo = 1 a sábado = 7.
Otras funciones DateTime disponibles

función Now: DateTime;
función Fecha: DateTime;
función Time: DateTime;
función DateTimeToStr (dt: DateTime): string;
función StrToDateTime (str: String): DateTime;
función DateToStr (Fecha: DateTime): String;
función StrToDate (Str: String): DateTime;
TimeToStr función (Tiempo: DateTime): String;
función strtotime (Str: String): DateTime;
DayOfWeek función (dt: DateTime): Integer;
FormatDateTime función (Formato: String; dt: DateTime): String;
función ESAÑOBISIESTO (año: Entero): Boolean;
función IncMonth (dt: DateTime; nm: Entero): DateTime;
procedimiento DecodeDate (dt: DateTime; yy var, mm, dd: Entero);
función EncodeDate (yy, mm, dd: Entero ): DateTime;
procedimiento DecodeTime (dt: DateTime; hh var, mm, ss, ms: Integer);
EncodeTime función (hh, mm, ss, ms: Integer): DateTime;

Toma de decisiones y selección

Guiones PAL pueden comparar valores y actuar sobre estos resultados. Los operadores básicos son:

Operando	Descripción
=	Igual a
<>	No igual a
<=	Menos que o igual a
> =	Más que o igual a
NO	NO operador lógico
Y	Lógico operador AND
O	Operador lógico OR
{}	Paréntesis usado para lógicamente expresiones de grupo

Todos estos son llamados lógico o operadores "booleanos", ya que el resultado final siempre es VERDADERO o FALSO.

Ejemplo:

Var B: Boolean;
var X: Integer = 0;
Var Y: Integer = 1;
Var Z: Integer = 2; B: = X <0; {B = FALSO} B: = X = 0; {B = TRUE} B: = Z> Y; {B = TRUE} B: = NO (X> 0); {B = TRUE} B: = (X <0) O (X = 0); {B = TRUE desde X = 0} B: = (X <0) Y (X = 0); {B = FALSO} B: = (X <= 0); {B = TRUE} B: = NO B; {Valor Cambios de true a false, o false a true} B: = (X <> Z); {B = TRUE, ya que X no es igual a Z} B: = (1 + 1); {¡¡Inválido!! No boolean resultado}












Las expresiones lógicas se pueden utilizar en SI o declaraciones CASE (ver directamente abajo), o REPEAT..UNTIL y WHILE..DO bucles.
  Nota muy importante: Debido a los problemas de aplicación, no se puede hacer PAL.WaitForXXX dentro de un bloque instrucción IF.

Lógica de selección básico

El bloque lógico IF..THEN se utiliza para especificar qué secciones de código necesita ser ejecutado en función de una expresión lógica.

Ejemplo:

SI DayOfWeek (ahora) = Domingo ENTONCES
WriteLn ('Hoy es domingo!')
MÁS
WriteLn ('Hoy no es Domingo ...');



SI (Ahora> T ['14: 30: 00 ') y (DayOfWeek (ahora) = Sábado) ENTONCES
WriteLn (' Es tiempo para mi Sábado show en vivo "!);



SI (Ahora> T ['14: 30: 00 ') y (DayOfWeek (ahora) = Sábado) ENTONCES
COMIENZA
WriteLn ('! Es hora de que mi Sábado show en vivo ');
WriteLn (' por lo que permite ponerse en marcha ... ');
FIN;

A veces usted tiene que comprobar muchos valores al mismo tiempo. Puede utilizar anidado IF, por ejemplo:

SI (A = 1) ENTONCES
COMIENZO
{Hacer cosas}
{Y algunos más}
END
ELSE IF (A = 2) ENTONCES
{hacer cosas}
MÁS
{Hacer otras cosas};

Pero utilizando declaraciones CASE son generalmente una solución más elegante:

CASO DE
1: comenzar
{Hacer cosas}
{Y algunos más}
final;
2: {Hacer cosas};
else {hacer otras cosas}
FIN;

A necesita ser un ordinal expresión o una expresión de cadena. Expresiones ordinales son los valores de datos en un rango, es decir, número entero y booleano son valores ordinales, flotador no lo es.

Ejemplo:

var a: String = 'ABC';
CASO DE
'ABC': WriteLn ('Este es nuestro ABC');
'XYZ': WriteLn ('Este es nuestro Manual técnico');
FIN;

Bucles y Iteración

En la programación se encontrará a menudo la necesidad de repetir ciertos comandos varias veces hasta que se cumpla una determinada condición. Guiones PAL contienen algunas de las formas básicas para lograrlo.
a) En primer lugar, el guión en sí puede repetir.
Al establecer

PAL.Loop: = true;

todo el guión se repetirá una vez que ha llegado al final. Si se establece en false durante la ejecución, el script se detendrá una vez que se llega al final, (Falso es el valor predeterminado).
b) El uso de un bucle 'Para'

var T: Integer;
para T: = 0 a 20 hacer
comenzar
WriteLn (T);
fin;

c) Repita .. hasta bucle

T: = 0;
repetir
WriteLn (T);
T: = T + 1;
hasta (T> 10);

T: = 33;
repetir
WriteLn ('Usted verá esta línea exactamente una vez!');
T: = T + 1,
hasta que (T> 10);

d) bucle While..do

T: = 0;
while (T <20) hacen
comenzar
WriteLn (T);
T: = T + 1;
fin;


T: = 33;
mientras que (T <10) hacer
WriteLn ('Usted NUNCA ver esta línea!');
T: = T + 1;
fin;

Tenga cuidado con los bucles infinitos! Loops siempre debe tener un código que hará que para salir, finalmente, el bucle.
Estos son ejemplos de bucles infinitos:

T: = 0;
while (T <10) hacen
comenzar
WriteLn (T);
fin;


repetir
T: = 0;
T: = T + 1,
hasta que (T> 10);

Esperando....
Aunque técnicamente no es parte del idioma base PAL, es crucial que cubrimos el tema de la espera en esta sección, ya que es una parte fundamental de la mayoría de los guiones PAL tales. Un script PAL ejecuta un comando o un bloque de comandos cada segundo. Para la mayoría de las secuencias de comandos que esto es demasiado rápido - por lo general sólo tienen que tomar acción una vez una canción cambios, o una vez que se alcanza un cierto tiempo. En teoría, podríamos crear un bucle que se se cumple bucle hasta que la condición, pero esto sólo perder CPU.
Así, en PAL tenemos muchos comandos de espera, a menudo denominados colectivamente como comandos "WaitForXXX". (Y no, no estamos hablando de descargas porno lentos)
PAL es compatible con 3 comandos de espera:

PAL.WaitForPlayCount (Conde);
PAL.WaitForQueue (Count);
PAL.WaitForTime (Tiempo);
El uso de estos comandos causará SAM Broadcaster a "pausa" el guión PAL hasta que se produce el evento especificado.

Ejemplos:

PAL.WaitForPlayCount (2);
Este comando esperará exactamente dos canciones para jugar antes de que se reanude el guión. Esto se hace mediante el establecimiento de un contador internamente tan pronto como se ejecuta el WaitForPlayCount, a continuación, para cada canción que se carga en una cubierta y comienza a reproducir el contador se disminuido. Tan pronto como el contador llegue a cero - la secuencia de comandos se reanuda.

PAL.WaitForQueue (2);

Este comando esperará a que la cola para contener exactamente dos pistas. Así que si la cola tenía 4 pistas, y usted comienza la reproducción de pistas de la cola, la secuencia de comandos con el tiempo se seguirá una vez que la cola alcanza 2 pistas. Por otro lado, si la cola tenía pistas cero en el mismo, este comando esperará hasta que se añaden 2 pistas a la cola. Piense con cuidado cuando se utiliza este comando - puede ser difícil, especialmente si tiene varios guiones PAL gestión de pistas de la cola. Es muy posible que otros scripts pueden mantener la cola completa (es decir, en 4 pistas) y que la cola nunca alcanzarán 2 pistas.

PAL.WaitForTime (Tiempo);

Este es de hecho un comando muy útil de espera. Lo primero que necesitamos para cubrir las diferentes maneras en que esto puede ser llamado. El "tiempo" se puede especificar de muchas maneras.
a) Como una variable DateTime

var D: DateTime;
D: = ahora + 1; {} Mañana este tiempo
PAL.WaitForTime (D);

Otro ejemplo - mediante el objeto timemask T aprendimos antes. Esto también devuelve un valor DateTime.

PAL.WaitForTime (T ['14: 00: 00 ']);

b) Como una máscara cadena de tiempo.
El formato de máscara mismo tiempo exacto utilizado con el objeto de máscara tiempo T se puede utilizar en el comando WaitForTime.

Ejemplo:

PAL.WaitForTime ('+ 00:00:10'); {## Espere 10 segundos}
PAL.WaitForTime ('14: 30: 00 '); {## Espere a 14:30 HOY}
PAL.WaitForTime ('XX: 00: 00'); {## Esperar para la próxima hora} PAL.WaitForTime ('14: 00: 00 '+ 1); {## Este no es válido! Vea a continuación la sintaxis correcta}



Use este lugar:

PAL.WaitForTime (T ['14: 00: 00 '] + 1); {## Esto funciona - utiliza el valor DateTime}

Así que en resumen - usted puede pasar una variable DateTime o el valor, o pasar una máscara cadena de tiempo.
Hay un problema de lógica sutil que necesita para estar al tanto de como desarrollador PAL.
Digamos que usted tiene este script PAL:

PAL.Loop: = true;
PAL.WaitForTime ('10: 00: 00 ');
WriteLn (' Ahora es el 10 de la mañana ');
PAL.WaitForTime ('20: 00: 00');
WriteLn ('Ahora es 20:00 de la tarde' );
PAL.WaitForTime ('23: 59: 59 ');

Si se inicia este script a las 7 de la mañana, entonces todo funcionará como se espera. SAM Broadcaster esperará hasta las 10 am, escriba el mensaje, espera a 20:00, escriba el mensaje, y luego esperar hasta 1 segundo antes de la media noche antes de que el script se reinicia - listo para el día siguiente.
Sin embargo, si este script se inicia a las 5 pm, a continuación, SAM Broadcaster comprobará la primera PAL.WaitForTime ('10: 00 '); y darse cuenta de que 10 a.m. <17:00, por lo que no va a esperar e inmediatamente imprimir el mensaje "Ahora es el 10 de la mañana". Entonces, desde este punto en adelante va a funcionar como se esperaba - es decir, esperar hasta 20:00, escriba el mensaje, y luego esperar hasta 1 segundo antes de la media noche antes de que el guión se reinicia - listo para el día siguiente.
Desarrolladores PAL más avanzados saben y escriben guiones un poco más complejas para saltar sobre secciones del día que ya les pasó por sin ejecutar el código. Proporcionamos un ejemplo rápido de cómo esto puede lograrse - aunque hay muchos otros métodos que se pueden utilizar.

Oldtime var: DateTime;
Oldtime: = Ahora; {Obtener el tiempo el guión comenzó}

PAL.Loop: = true;
PAL.WaitForTime ('10: 00: 00 ');
si (Oldtime <= T ['10: 00: 00']), entonces WriteLn ('Ahora es el 10 de la mañana');
PAL.WaitForTime ('20: 00:00 ');
si (Oldtime <= T ['20: 00: 00']), entonces WriteLn ('Ahora es 20:00 de la tarde');
PAL.WaitForTime ('23: 59: 59 ');

Tenga en cuenta que no queremos estar esperando dentro de una instrucción IF, así que asegúrese de colocar la instrucción IF después de su espera. (Ver más abajo) La ejecución de esta secuencia de comandos después de que el 10 a.m. solamente resultará en que se ejecuta el código 20:00, siempre que el guión se inició antes de 20:00. Esto resuelve totalmente el problema de scriptings se inició al final del día producir resultados no deseados.

Ahora, algunos conceptos importantes acerca de espera:

No se puede esperar dentro
a) declaraciones IF..THEN
b) declaraciones CASE..OF
c) las funciones y procedimientos personalizados
PAL simplemente saltar sobre el comando de espera. Este es un resultado desafortunado de la aplicación de la PAL núcleo del lenguaje se basa en. Este lenguaje no estaba destinado a ser ejecutar línea por línea, sino más bien como un programa completo. Así que tuvimos que modificar significativamente este lenguaje para satisfacer nuestras necesidades. Desafortunadamente no hemos sido capaces de solucionar este problema para los bloques de instrucciones antes mencionadas.
La buena noticia es que hay formas de evitar este problema.
1. No espere funciones y procedimientos internos. Más bien repetir las líneas de código cuando sea necesario.
2. En el caso de las declaraciones IF..THEN y CASE..OF, utilice un bucle WHILE..DO lugar.

Ejemplo:

SI (A> B) LUEGO
comenzar
PAL.WaitForPlayCount (1);
fin;

Puede ser sustituido por:

var Maniquí: Boolean = true;
MIENTRAS (A> B) Y (dummy) HACER
comenzar
PAL.WaitForPlayCount (1);
Maniquí: = false;
fin;

Aunque, obviamente, no es la solución perfecta, que hace el trabajo. Oh, otro consejo. Usted puede utilizar la variable dummy si tiene muchos sustitutos que hacer. Sólo tienes que recordar que uno u otro conjunto Maniquí: = True; antes de que el bucle while.

La aceleración de la ejecución

PAL fue escrito para ser un proceso de baja prioridad dentro de SAM Broadcaster para que la calidad de audio no se ve afectado. Como resultado PAL ejecuta única línea de código cada segundo.
En cuanto a la ejecución del programa que son muy lento - pero para PAL Esto funciona perfecto 99% del tiempo.
Pero hay momentos en que es necesario que la ejecución inmediata. Por suerte PAL hace fácil con estos comandos:

PAL.LockExecution;
{hacer cosas}
PAL.UnlockExecution;

Ejemplo:

T: = 0;
Mientras que (T <100) hacer
comenzar
WriteLn (T);
T: = T + 1;
fin;

Este script se tardará al menos 100 segundos en ejecutarse. Mediante la adición de 2 líneas, podemos hacer que la secuencia de comandos ejecutar en menos de 2 segundos.

var T: Integer; PAL.LockExecution; T: = 0; Mientras que (T <100) hacer




comenzar
WriteLn (T);
T: = T + 1;
fin;
PAL.UnlockExecution;

Tenga cuidado sin embargo - SAM Broadcaster se "congelan", mientras que un script PAL está en ejecución bajo llave - por lo tanto no permanece bloqueado durante largos períodos de tiempo. Usted puede incluso comprobar el tiempo que el código ha venido ejecutando, y luego tomar un breve respiro de vez en cuando, ya sea usando un comando "WaitForXXX", o rápidamente desbloquear y luego bloquear la ejecución de nuevo.

Objetos

PAL es un lenguaje de programación orientada a objetos totalmente. Aunque lo más probable es que no va a utilizar mucho POO ti mismo, PAL contiene muchos objetos que usted necesita para ser capaz de utilizar.
(POO = Objeto Programación Orientada)
Los objetos son casi como las variables, excepto que los objetos también pueden realizar acciones a través de métodos
Los objetos también almacenar datos a través de las propiedades. Algunas propiedades son de sólo lectura, sin embargo, es decir, sólo se pueden utilizar para leer los valores, no cambiar los valores.

Ejemplo:

ActivePlayer.FadeToNext; {Método}
ActivePlayer.Volume: = 255; {Read / Write propiedad}
WriteLn (ActivePlayer.Duration); {Propiedad de sólo lectura} var obj: TPlayer; Obj: = ActivePlayer; Obj.FadeToNext; Objetos apoyo herencia: var obj: TObject; Obj: = ActivePlayer; si obj es TPlayer entonces {Compruebe si el objeto es del tipo correcto} TPlayer (Obj) .FadeToNext; {Objeto encasillado para corregir tipo y usarlo}













También puede crear y destruir muchos de sus propios objetos:

Lista var: TStringList;
de lista: = TStringList.Create; {Crear un objeto stringlist}
{hacer cosas con objeto aquí}

List.Free; {Recuerde liberar el objeto de la memoria una vez que haya terminado con él}

Sección 1 minuto resumen:

Declaración de variables:

const A = 'Hola mundo!';
const A = 123; var V: Integer; var V: String; var V: Array [1..5] of Integer; var V: Arsenal de Integer; var V: TMyClass; var V: Integer = 1; var V: String =; '¡Hola, mundo! "

Mates:

m: = a + b;
m: = a - b;
m: = a * b;
m: = a / b; {Float única}
m: = a div b; {Solo Integer; Descarta el resto}
m: = a mod b; {Solo Integer; El resultado es más que el resto}
m: = -m;

Lógica:

NO es una
A o B
A y B
un XOR b
<b
a <= b
a> b
a> = b
a <> b
a = b

Fundición:

Float (x)
DateTime (x)

Escriba comprobación y fundición:

a es TMyClass
TMyClass (a)

Selección:

si {expresión lógica} entonces
{Hacer cosas}
más
{Hacer cosas};


caso {valor} de
1: {} Hacer cosas
2..4: {Hacer cosas}
5,6,7: {Hacer cosas}
else {Hacer cosas}
fin;

Bucles:

var C: Integer;
Para C: = A a B hacer
comenzar
{Hacer cosas}
fin;


mientras {expresión lógica es verdadera} hacer
comenzar
{Hacer cosas}
fin;


repetir
{Hacer cosas}
hasta {expresión lógica es verdadera};

Esperando:

PAL.WaitForTime(TimeMask/DateTime);
PAL.WaitForPlayCount(SongCount);
PAL.WaitForQueue(NoOfItemsInQueue);

La aceleración de la ejecución:

PAL.LockExecution;
PAL.UnlockExecution;

Algunas advertencias sobre scripting PAL

Scripting PAL es un potente lenguaje de programación. Con este poder viene una gran responsabilidad.
Guiones PAL incorrectamente escritas pueden tener muchos efectos secundarios negativos, los que incluyen:
1. Causa SAM Broadcaster se bloquee / congelación.
2. Los errores de excepción Causa en SAM Broadcaster, que afectan a la estabilidad en SAM Broadcaster.
3. Aunque PAL hace la recolección de basura automática en el reinicio de la escritura, es posible escribir scripts que consumen toda la memoria disponible si la asignación de memoria se hace en bucles de larga duración.
4. PAL le da acceso directo a la base de datos SQL. Es posible utilizar consultas SQL para borrar por completo o destruir la base de datos y la integridad de los datos.
5. PAL le da el poder para trabajar con archivos en su disco duro local y de la red. PAL se puede utilizar para borrar o modificar los archivos.
Así que ten cuidado de los scripts de ejemplo que se descargan de internet. Revise primero para asegurarse de que se escriben bien y no afectarán su emisión negativamente. Tampoco se recomienda el desarrollo de guiones PAL en una máquina de producción. Lo mejor es tener una copia espejo de SAM Broadcaster se ejecuta en otra máquina, y luego el desarrollo de secuencias de comandos en esta máquina.

Sección 2 - Los principales objetos SAM Broadcaster

Aunque SAM Broadcaster es un programa complejo, que puede ser descrito como 4 componentes principales.
2.1. La biblioteca de lista de reproducción / media de pistas.
2.2. Selección de música lógica y reglas de lista de reproducción.
2.3. El motor de audio que consta de diferentes canales de audio representados por Torres / jugadores.
2.4. Por último, los codificadores y relés estadísticos.
Todos los demás objetos que se encuentran en el lenguaje de scripting PAL se utilizan básicamente para apoyar estas funciones principales. En esta sección vamos a discutir algunos de estos principales objetos y utilizarlos en algunos scripts PAL del mundo real para demostrar su funcionalidad.

2.1 La mediateca / lista de reproducción

SAM Broadcaster almacena todo lo que jugó en la biblioteca de medios. O más correcto, SAM Broadcaster sólo puede reproducir una pista si existe en la biblioteca multimedia. Sin ella SAM Broadcaster no sería capaz de hacer las normas de gestión de lista de reproducción y la lógica de selección avanzadas necesarias para una emisora ​​de radio profesional.

2.1.1 La importación o exportación de archivos a / de la mediateca

Importador

Puede agregar archivos a cualquiera de una categoría o directamente a la cola utilizando varios comandos PAL.
Algunos ejemplos:

. CAT ['MyCategory'] AddDir ('c: \ música \', ipBottom);
. CAT ['MyCategory'] AddFile ('c: \ música \ test.mp3', ipBottom);
. CAT ['MyCategory'] AddList ('c: \ música \ playlist.m3u', ipBottom);
CAT ['MyCategory'] .AddURL ('http: // localhost: 8000 / test.mp3', ipBottom);

Los mismos comandos también se pueden utilizar para añadir archivos a la cola

Queue.AddDir ('c: \ música \', ipBottom);
Queue.AddFile ('c: \ música \ test.mp3', ipBottom);
Queue.AddList ('c: \ música \ playlist.m3u', ipBottom);
Queue.AddURL ('http: // localhost: 8000 / test.mp3', ipBottom);

Exportador

Comenzando con Broadcaster4 SAM, ahora se puede almacenar fácilmente el contenido de una categoría o la cola en el archivo. Esto puede ser muy útil cuando se utiliza con el software de programación de música como M1 SE (http://www.spacialaudio.com/products/m1se)

Exportación de una categoría se puede hacer a través de los siguientes comandos PAL:

. CAT ['MyCategory'] SaveAsM3U ('c: \ list.m3u'); {Exportar como lista de reproducción M3U}
CAT ['MyCategory'] SaveAsCSV. ('C: \ list.csv'); {Exportar como archivo de datos CSV}

Exportación de la cola se puede hacer de la siguiente manera:

Queue.SaveAsM3U ('c: \ list.m3u'); {Exportar como lista de reproducción M3U}
Queue.SaveAsCSV ('c: \ list.csv'); {Exportar como archivo de datos CSV}

Nota: Los archivos CSV son archivos de hojas de cálculo, también conocido comúnmente como archivos delimitados por comas.

2.1.2 Uso de la biblioteca de medios para la rotación de encargo "clockwheels"

Emisoras serios saben la importancia de etiquetar correctamente su música, es decir, asegurándose de que el artista, título, álbum y otros campos se desarrollan adecuadamente. Una vez hecho esto los musicales, jingles, promos e incluso anuncios se clasifican en varias categorías. Una vez que todo ese trabajo duro está hecho, la programación de música en un formato de radio profesional se convierte en un proceso más sencillo.
En SAM programación de música Transmisor convierte en la tarea básica de la selección de una canción de una categoría determinada, y agregarlo a la cola. Cuando selecciona una pista en una categoría, SAM Broadcaster puede utilizar muchas lógicas diferentes http: //www.spacialaudio.com/products/sambroadcaster/help/sambroadca ...) y luego aplicar ciertas reglas de selección (http: //www.spacialaudio .com / products / sambroadcaster / help / sambroadca ...) para obtener la mejor pista que cumple con todas estas reglas.
También puede especificar si la pista debe ir a la parte superior o la parte inferior de la cola. Le mostraremos más adelante cómo poner esto en buen uso.
Así que vamos a saltar con un guión muy simple:

PAL.Loop: = true;

Cat ['Tracks'] QueueBottom (smLemmingLogic, EnforceRules).;
Cat ['Música (Todos)'] QueueBottom (smLRPA, EnforceRules).;
Cat ['Hot Golpea'] QueueBottom (smLRP, EnforceRules).;
Cat ['Adz'] QueueBottom (smLRPA, Norules).;

PAL.WaitForPlayCount (4);

En el guión anterior nos fijamos primero el guión de bucle / reinicio. Siguiente insertamos 4 pistas en la parte inferior de la cola. La primera pista vendrá de la categoría de "pistas" y vamos a utilizar la lógica lemming aleatorio para seleccionar la canción, y luego hacer cumplir nuestras normas de reproducción de la selección de la canción. Hacemos cosas similares, pero ligeramente diferentes para las otras 3 categorías (ver si puede detectar y comprender la diferencia!).
Por último, esperamos SAM Broadcaster jugar 4 pistas, antes de que el guión termina y reinicia / bucles. (¿Por qué esperar? ¿Qué pasaría si no esperar?)
El resultado final de este script es que jugamos
Una canción de la categoría de "Tracks"
Una canción de la categoría "Música (Todo)"
Una canción de la categoría "Hitz caliente"
Una canción de la categoría "Adz"
Este formato de la programación continuará hasta que el guión PAL se detiene manualmente. Inserción de jingles, promos y los ID de estación en su formato también es relativamente simple.

Ejemplo:

PAL.Loop: = true;

Cat ['Tracks'] QueueBottom (smLemmingLogic, EnforceRules).;
Cat ['Música (Todos)'] QueueBottom (smLRPA, EnforceRules).;
Cat ['Hot Golpea'] QueueBottom (smLRP, EnforceRules).;
Cat ['MyPromos'] QueueBottom (smLRP, Norules).;

PAL.WaitForPlayCount (4);

Cat ['Tracks'] QueueBottom (smLemmingLogic, EnforceRules).;
Cat ['Música (Todos)'] QueueBottom (smLRPA, EnforceRules).;
Cat ['Hot Golpea'] QueueBottom (smLRP, EnforceRules).;
Cat ['MyJingles'] QueueBottom (smLRP, Norules).;
PAL.WaitForPlayCount (4);

Observe cómo teníamos que repetir las categorías de canciones, así que pudimos colocar 1 Promoción después de un set y luego 1 cascabeleo tras otro conjunto - y tener esta repetición.
También noto que he usado los "Norules" en la lógica.
Pasemos a un ejemplo un poco más complejo. Aquí vamos a utilizar dos guiones PAL separados que se ejecutan en el momento SAM Broadcaster para producir nuestra lógica lista de reproducción. PAL # 1 será responsable de programar nuestra música, mientras que PAL # 2 será responsable de la adición de jingles, promos y Adz al sistema.

PAL 1

PAL.Loop: = true;

Cat ['Tracks'] QueueBottom (smLemmingLogic, EnforceRules).;
Cat ['Música (Todos)'] QueueBottom (smLRPA, EnforceRules).;
Cat ['Hot Golpea'] QueueBottom (smLRP, EnforceRules).;

PAL.WaitForQueue (0);

PAL 2

PAL.Loop: = true;

PAL.WaitForPlayCount (5);
. Cat ['MyJingles'] QueueTop (smLRP, Norules);

PAL.WaitForPlayCount (3);
. Cat ['MyPromos'] QueueTop (smLRP, Norules);
Cat ['MyAdz'] QueueTop (smLRP, Norules).;

Un par de cosas para prestar atención a:

- Ahora usamos el comando WaitForQueue en PAL 1 para saber cuándo insertar más canciones en la cola.
- PAL 2 utiliza QueueTop ahora, porque puede haber canciones en la cola - y queremos colocar este cascabeleo / promo / contenido de los anuncios en el siguiente punto a-jugada-ser en la parte superior de la cola.
- Además, tenga en cuenta que MyAdz se colocará por encima de MyPromos en la cola. (En orden inverso - asegúrese de entender por qué sucede esto)

2.1.3 Programación de la publicidad en el SAM Broadcaster (vía StreamAdz)

Desde v4 SAM Broadcaster, SAM Broadcaster tiene una integración directa con la plataforma de publicidad de entrega de gran alcance llamada StreamAdz (http://www.spacialaudio.com/products/streamadz).
En lugar de seleccionar una pista de una categoría, sólo tiene que ejecutar el comando PAL StreamAdz para insertar una duración especificada de anuncios. SAM Broadcaster seleccionará automáticamente uno o más anuncios para llenar el anuncio de bloque especificado.

Ejemplo:

StreamAdz ['Proveedores (Todos)'] QueueBottom (30).; {Selecciona un anuncio de cualquier proveedor}
StreamAdz ['Proveedor C'] QueueBottom (60).; {Selecciona un anuncio utilizando proveedor SOLO C}

La siguiente secuencia de comandos demostró una fácil escritura de anuncio programación, la inserción de 2 minutos de publicidad cada 15 minutos.

PAL.Loop: = true;
StreamAdz ['Proveedores (Todos)'] QueueBottom (120).; {Inserte 2 minutos de publicidad}
PAL.WaitForTime ('+ 00:15:00'); {Espere 15 minutos}

2.2 Música selección lógica y reproducción reglas.

Pistas almacenadas en categorías se pueden seleccionar utilizando diversos lógica de selección. Por ejemplo, smRandom seleccionará una pista aleatoria de la categoría, mientras que smLRP seleccionará la canción que no ha jugado durante más tiempo. (Recientemente Menos jugados)
Una canción sólo se puede seleccionar si se ajusta a las reglas lógicas de reproducción. Estas normas tienen por objeto limitar la cantidad de veces que una canción, artista o álbum repite dentro de un período de tiempo. Por ejemplo, será muy malo para reproducir la misma canción de regreso a la vuelta! En las leyes de EE.UU. la DCMA, también el permiso para repetir canciones, artistas o álbumes con demasiada frecuencia.
Reglas no-no-repeat no obstante se aplican a los jingles, promos, anuncios, etc., en la misma forma. Por eso, en general que usamos la bandera Norules al seleccionar este tipo de contenido. Sin embargo, todavía no quiere repetir éstos con demasiada frecuencia. Jugando el mismo jingle de back-to-back o jugar el mismo anuncio de back-to-back es tan malo. La forma más fácil de evitar esto es usar la regla smLRP. De esa manera SAM Broadcaster hará un ciclo a través del contenido de una manera de arriba a abajo.
Incluso esto no funciona, aunque cuando la inserción de varias pistas en la cola, ya que se aplica ningún tipo de verificación de repetición - la misma canción se añadirá a la cola varias veces!
Para resolver esto necesitamos un guión especial PAL que modifica las reglas reproducción, inserte el contenido, y luego restaura el contenido de edad. Ahora usted es libre de nuevo para utilizar cualquier método de lógica de selección que desea!

Ejemplo:

{Declarar un procedimiento que definiremos más adelante}
Norules procedimiento (Mycat: String; lógicos: Integer); reenviar;

PAL.Loop: = true;
Norules ('MyAdz', smLRP);
Norules ('MyAdz', smRandom);
Norules ('MyAdz', smLRP);

PAL.WaitForPlayCount (8);

{================================================= =======}
Norules procedimiento (Mycat: String; lógicos: Integer);
var tArtist, tAlbum, TTITLE: Integer;

comenzar
{Guarda las reglas actuales para poder restaurarlos posteriormente}
tArtist: = PlaylistRules.MinArtistTime;
TTITLE: = PlaylistRules.MinSongTime;
tAlbum: = PlaylistRules.MinAlbumTime;

{Establece algunas reglas de repetición muy bajas - 1 minuto}
PlaylistRules.MinAlbumTime: = 1;
PlaylistRules.MinArtistTime: = 1;
PlaylistRules.MinSongTime: = 1;

{Insertar contenido al principio de la cola utilizando nuestras nuevas reglas}
CAT [Mycat] .QueueTop (Lógica, EnforceRules);

{Restaurar reglas originales}
PlaylistRules.MinArtistTime: = tArtist;
PlaylistRules.MinSongTime: = TTITLE;
PlaylistRules.MinAlbumTime: = tAlbum;
fin;
{================================================= =======}

Mientras SAM Broadcaster debe ser capaz de atender a todas sus necesidades, algunas personas tienen necesidades muy específicas para su rotación. Por suerte, con el poder de PAL, la mayoría han encontrado maneras de alcanzar sus metas con algunas secuencias de comandos ingenioso.
Este script PAL aplica 5 reglas personalizadas a las pistas para decidir qué pista para jugar al lado. La única desventaja de este guión es que se necesita una gran cantidad de tiempo de CPU para seleccionar una sola canción.

2.3. El motor de audio que consta de diferentes canales de audio representados por Torres / jugadores.

PAL permite controlar diversos componentes de audio en los engine.This audio puede ser muy útil para hacer elementos de audio seguro jugar exactamente como usted desea. Vamos a ir a través de los componentes principales, junto con algunos ejemplos.
Decka, DeckB, Aux1, Aux2, Aux3 y SoundFX son todos los tipos de jugadores (Clase TPlayer)
Esto significa que todas las mismas operaciones se aplican a todos estos jugadores. (Tenga en cuenta que VoiceFX actualmente no se puede acceder a través de PAL desde pistas deben, en general, no se pueden reproducir más de este jugador. Esto está destinado exclusivamente para la operación por voz)

La lectura que se está reproduciendo información de la canción

Este script leerá la información de la canción de la pista cargada en Decka, y luego imprimir la información.

var Canción: TSongInfo;
Canción: = DeckA.GetSongInfo;

si Canción = nil entonces
WriteLn ('No hay canciones carga en Decka!')
más
comenzar
WriteLn ('Artista:' + Song ['artista']);
WriteLn ('Título:' + Song ['title']);
WriteLn ('Álbum:' + Song ['disco']);
WriteLn ('Duración:' + Song ['duración']);
fin;

Song.Free;

Observe cómo probamos si la Canción = nula, porque si ese es el caso tratando de leer la información sobre el objeto canción hará que violaciónes de acceso a memoria, ya no existe el objeto!

El uso de las funciones de utilidad

PAL viene con algunas muy útiles funciones incorporadas que puede utilizar. Estos le proporcionan acceso directo al objeto jugador correcto. (Entre Decka y DeckB solamente!)

ActivePlayer

Esto devuelve el objeto jugador considerado el jugador "activo". Si sólo hay una cubierta es jugador de la pista, a continuación, esta canción va a ser el jugador activo. Si ambas cubiertas están jugando una pista, a continuación, la cubierta con la mayor duración restante se considera la cubierta activa. Si NI Decka o DeckB tienen ninguna pista jugando, esta función devuelve NIL. Es muy importante que compruebe el valor NIL, a menos que esté seguro de que siempre habrá una cubierta activa.

IdlePlayer

Una cubierta se considera inactivo si no hay canción está en la cola en la cubierta, y la cubierta no está jugando activamente cualquier pista. Si ambas cubiertas están ociosos, Decka se devuelve como el objeto inactivo. Si ambas cubiertas se ponen en cola para arriba, o jugar en forma activa una pista - entonces esta función devolverá NIL!

QueuedPlayer

Un jugador se considera en modo de cola si la cubierta tiene un objeto canción cargada en la cubierta, pero la cubierta no está actualmente jugando activamente cualquier pista. Si las dos cubiertas son ya sea en reposo o activo, entonces esta función devolverá NIL! De lo contrario, volverá la primera cubierta en cola.
En general, la función ActivePlayer se utiliza mucho más que cualquiera de los otros. La mayoría de nuestros ejemplos se ocupará de esta función.

Por ejemplo comprobar si SAM Broadcaster está activo:

si (ActivePlayer = nil), entonces
WriteLn ('ADVERTENCIA !!! Nada está jugando ??');

Este script esperará a que el la hora de inicio de página y luego insertar una noticia. A continuación, se desvanecen de inmediato a esta noticia.

PAL.Loop: = true;
PAL.WaitForTime ('XX: 00: 00');
Queue.AddFile ('c: \ noticias \ news.mp3', ipTop);
ActivePlayer.FadeToNext;

Aquí es un poco más de un guión complicado. Éste será insertar algunos revestimientos de más de la música, pero sólo lo hará si:
a) La música tiene una introducción de más de 5 segundos
b) La música es una canción normal (es decir, no una promo, tintineo, publicidad, noticias)

{ Acerca de:
Este script jugará un forro en Aux1 tan pronto como se inicia una nueva pista
El revestimiento solamente se jugará si
a) La canción tiene una introducción de una duración mínima especificada
b) La canción es de tipo S, es decir, una canción normal.

Entonces el guión esperará el tiempo especificado antes de intentar jugar otro revestimiento.

Este script puede ayudar a la marca de su estación y hacer que suene como una verdadera estación terrestre comercial.

Uso:
a) Asegúrese de que utiliza el editor de información de la canción para especificar los tiempos de introducción para sus pistas!
b) Asegúrese de que la configuración de AGC en Aux1 es de su agrado. Ajuste también el volumen un poco más fuerte
en Aux1 para que pueda escuchar claramente el forro por encima de la cubierta de audio activo.
c) Editar los detalles de configuración a continuación.

Asegúrese de cambiar la categoría a la que se utiliza para almacenar sus forros.
}

{ CONFIGURACIÓN }
{================================================= =}
const MIN_INTRO = 5 * 1,000; //5 segundos
const MIN_WAIT = "00: 15: 00 '; // Espere 15 minutos entre forros
const LINERS_CATEGORY = 'Liners';

{ IMPLEMENTACIÓN }
{------------------------------------------------- -}
funcionar ExtractIntro (Canción: TSongInfo): Integer; reenviar;

var canción, Delineador: TSongInfo;
var espera: Boolean = true;
var Intro: Integer = 0;

Aux1.Eject;

{Paso 1: Poner en cola de la cubierta, listo para el juego}
Liner: = CAT [LINERS_CATEGORY] .ChooseSong (smLRP, Norules);
si (Liner = nil), entonces
WriteLn ('Sin forro válida encontró')
else if (no Aux1.QueueSong (Liner)) entonces
WriteLn ("No se pudo hacer cola canción: '+ Liner [' nombre ']);

{Espere a que una canción es válido con la intro}
mientras espera hacer
comenzar
{Paso 2: Esperar a que la canción para cambiar}
PAL.WaitForPlayCount (1);

{Paso 3: Grab actual información de la canción}
Canción: = ActivePlayer.GetSongInfo;

si (Canción = nil), entonces
WriteLn ('El jugador activo no contenía información de la canción ??')
más
comenzar
{Extraer el momento de introducción - esto es un poco complicado}
Intro: = ExtractIntro (Song);
{Empieza a jugar el revestimiento si la canción actual coincide con nuestras reglas}
si (Canción ['songtype'] = 'S') y (Intro> = MIN_INTRO) entonces
comenzar
Aux1.Play;
Esperando: = false;
fin;
Song.Free; Canción: = nil;
fin;
fin;

{Espere 5 minutos antes de que nos hacemos todos de nuevo}
PAL.WaitForTime (MIN_WAIT);
PAL.Loop: = true;

{................................................}
funcionar ExtractIntro (Canción: TSongInfo): Integer;
var P: Integer;
XFade: String;

comenzar
Resultado: = -1;
XFade: = Trim (Canción ['Xfade']);
WriteLn ('cadena de decodificación XFade');
WriteLn ('XFade:' + XFade);
si XFade = '' después
Resultado: = -1
más
comenzar
P: = Pos ('& i =', XFade);
si (P> 0) entonces
comenzar
Eliminar (XFade, 1, P + 2);
P: = Pos ('&', XFade);
si (P> 0) entonces
Eliminar (XFade, P, Longitud (XFade));
Resultado: = StrToIntDef (XFade, -1);
WriteLn (hora Intro detectado: '+ XFade);
fin;
fin;
fin;
{------------------------------------------------- -}

Otros métodos y funciones

Aquí sigue una discusión rápida en otros métodos y propiedades disponibles en el objeto TPlayer, y cómo pueden ser utilizados.

Propiedades:

La propiedad CURTIME puede ser monitoreado para ver cuando una canción se está acercando a su fin (cuando se compara a la propiedad duración) y luego se puede tomar alguna acción justo antes de que se inicie o en cola la siguiente canción.

Ejemplo:

Var Hecho: Boolean = false;

mientras que no se hace hacer
comenzar
if ((ActivePlayer.Duration> 0) y ((ActivePlayer.Duration-ActivePlayer.CurTime)> 10000)), entonces
empezar
WriteLn ('Esta canción va a terminar en 10 segundos!');
Hecho: = true;
fin;
fin;

Nota: Debido a la brecha asesino, puede ser menos de 10 segundos. Usted puede utilizar el valor real de los cálculos para obtener el valor correcto del tiempo restante.
Usted puede leer y escribir la propiedad Volumen de una cubierta. Esto puede ser utilizado para anuncios jugador, stationIDs, etc. más fuerte que otras pistas. Le recomendamos que utilice el editor de información de la canción para establecer la ganancia para cada pista de estos tipos de contenido de audio, pero este guión podría ser una solución alternativa.

var Hecho: Boolean = false;
var Canción: TSongInfo;

Si bien no Listo hacer
comenzar
si QueuedPlayer <> nil entonces
empezar
Hecho: = true;
Canción: = QueuedPlayer.GetSongInfo;
si (Canción <> nil) a continuación
caso canción ['songtype'] de
'S': QueuedPlayer.Volume: = 255;
'A', 'J', 'P': QueuedPlayer.Volume: = 350;
más QueuedPlayer.Volume: = 255;
fin; //caso
fin;
fin;

PAL.Loop: = true;
PAL.WaitForPlayCount (1);
Una vez más, este no es el método recomendado - pero sirve como un buen ejemplo de cómo utilizar la opción de volumen en PAL Nota: 255 es todo volumen, mientras que 350 es el volumen con ganancia extra aplicada..
Usando lo anterior como referencia, ahora debería ser capaz de crear también un script que puede ajustar el tempo o el tono de la cubierta de acuerdo con la canción que está en cola actualmente en ella. Esto puede ser usado para un script que hace la concordancia automática latido por ejemplo ...
Por favor consulte el manual de PAL sobre las distintas otras propiedades y métodos que no discutiremos en este capítulo.

2.4. Los codificadores y relés estadísticos

PAL también le da acceso a los codificadores y relés estadísticos.
Esto le da el poder para iniciar / detener los codificadores -, así como los datos de inserción de secuencias de comandos en la corriente.
Vamos a cubrir algunas de estas técnicas en las siguientes secciones.

2.4.1 relés Estadísticas

La clase Relés básicamente le permite el poder de hacer 5 cosas principales:
- Leer el estado de todos los relés
- Leer el recuento oyente actual
- Leer el recuento pico oyente
- Leer las ranuras oyente máximos disponibles
- Forzar una actualización de los relés de estadística.

Ejemplo:

{Imprima información relés - todo combinado} PAL.LockExecution; WriteLn ('visión general Relays'); WriteStr ('- Activo:'); si Relays.AtLeastOneActive entonces WriteLn ('online') else WriteLn ('Desconectado'); WriteStr ('- Espectadores:'); Writeln (Relays.Viewers); WriteStr ('- Pico:'); WriteLn (Relays.Viewers_High); WriteStr ('- Max:'); WriteLn (Relays.Viewers_Max); WriteLn (''); PAL.UnlockExecution;















{Imprima información relés - cada relé por sí} var I: Integer; PAL.LockExecution; porque yo: = 0 a Relays.Count-1 hacer






comenzar
WriteStr ('número Relay'); WriteLn (I);
WriteStr ('- Activo:'); Writeln (relés [I] .active);
WriteStr ('- Estado:'); Writeln (relés [I] .status);
WriteStr ('- Espectadores:'); Writeln (relés [I] .Viewers);
WriteStr ('- Pico:'); Writeln (relés [I] .Viewers_High);
WriteStr ('- Bitrate (kbps):'); WriteLn (relés [I] .Bitrate);
WriteStr ('- Formato:'); Writeln (relés [I] .formato);
writeln ('');
fin; PAL.UnlockExecution;

2.4.2 Codificadores

Partiendo / codificadoras Detención

Este es un simple script para iniciar todos los codificadores a las 7 de la mañana, y luego se detiene de nuevo a las 8 pm:

PAL.Loop: = true;

PAL.WaitForTime ('07: 00: 00 ');
Encoders.StartAll; PAL.WaitForTime ('20: 00: 00'); Encoders.StopAll;




También puede iniciar / detener un solo codificador utilizando el índice de matriz codificador. (Recuerde, contamos desde cero)

PAL.Loop: = true;

PAL.WaitForTime ('07: 00: 00 ');
codificadores [0] .start; PAL.WaitForTime ('20: 00: 00'); codificadores [0] .Stop;

Archivado

SAM Broadcaster tiene la opción de especificar que un codificador no hace absolutamente ninguna streaming, sino que se utiliza para archivar sólo el contenido. Esto le permite crear un segundo codificador cuyo único deber es archivar la corriente.
He aquí un ejemplo de script que está destinado para dos codificadores, donde encoder0 es el codificador de streaming real y encoder1 es el codificador de archivo. Este script hará que el archivo se divida en varias secciones, cada hora, pero de reiniciar los codificadores de la hora. Tenga en cuenta que esto no afectará el codificador de streaming en absoluto, ya que nunca se detiene!

PAL.Loop: = true;

PAL.WaitForTime ('XX: 00: 00');
codificadores [1] .Stop;
codificadores [1] .start;

Cambio de DJs

Una gran cantidad de estaciones de tener más de un DJ que opera la estación, la mayoría de las veces estos DJs están repartidos por todo el mundo. Emplean un truco ingenioso para cambiar entre sesiones de DJ. Si nuevo DJ desea iniciar la sesión, que inicien sesión en el panel de administración de SHOUTcast y patear codificador del DJ actual, y luego se conectan rápidamente con su propio codificador.
La siguiente secuencia de comandos PAL puede automatizar completamente este proceso:

{Acerca de:
Este script desconectar cualquier fuente conectada a un servidor SHOUTcast
y luego conecta esta transmitiendo SAM como la nueva fuente. Uso: a) Crear un único codificador MP3 para conectar con el servidor SHOUTcast. B) Proporcione los datos de su servidor SHOUTcast en el sección de configuración a continuación c) Utilice el Programador de eventos para iniciar este script PAL en el momento correcto.





}

{Configuración}
{============================================== ====}
const shoutcast_password = 'changeme';
= const shoutcast_host 'localhost';
const shoutcast_port = '8000';
{======================= ===========================} {APLICACIÓN} {------------------ --------------------------------} {Construir URL utilizado para enviar comandos al servidor SHOUTcast} URL var: String; URL : = 'http: // administrador:' + shoutcast_password + '@' + shoutcast_host + ':' + shoutcast_port + '/ admin.cgi mode = kicksrc?'; {fuente Kick desde el servidor SHOUTcast} WebToFile ('c: \ dummy.txt' , URL); {Ahora empieza y conectar todos los codificadores} {NOTA: Esto supone que sólo tiene un codificador} Encoders.StartAll; {CONSEJO: Utilice esta opción para iniciar un codificador específico: codificadores [0] .start;
















}
{------------------------------------------------- -}

Cambiar títulos de canciones

La clase codificador también le permite actualizar la información canción o título datos actuales que se envían al servidor de streaming. Ver TitleStreamBanners.pal para un ejemplo.
Nota: Esto también se puede hacer para cada codificador individual, en caso de que no tiene sentido lógico para cambiar los datos del título en todas sus codificadores activos. Por ejemplo, si usted tiene un codificador de archivado, lo más probable es que no desea actualizar los títulos de esta.

Scripts incrustados

Mientras SAM Broadcaster es una de las pocas codificadores (de hecho la única que conocemos) que soporta incrustados etiquetas ID3v2 dentro flujos MP3, debido a la falta de apoyo al jugador que sólo hablaremos de las secuencias de comandos Windows Media aquí.
Windows Media permite scripts incrustados en los datos de audio. Estos scripts se pueden utilizar para la visualización de los datos de la canción actual, los subtítulos o la sincronización de fotos y texto del audio actual externos. Utilizamos esta en nuestro sistema StreamAdz para sincronizar el texto y banners de publicidad con la publicidad de audio.
El siguiente script de ejemplo PAL es para mostrar la hora local actual en el área de subtítulos del reproductor Windows Media cada minuto.
Tenga en cuenta: Para que usted sea capaz de ver los datos de subtítulos, debe habilitar la vista de subtítulos dentro de su reproductor.
Menú-> reproducción> Leyendas y Subtitles-> Activar si está disponible

PAL.Loop: = true;
PAL.WaitForTime ("XX: XX: 00 ');
Encoders.WriteScript (" TITULO "," La hora local es ahora' + TimeToStr (ahora));

El tema está cerrado para los comentarios