---
title: roImagePlayer
slug: develop/es/roimageplayer
docTags: 
createdAt: 2025-03-11T07:07:18.732Z
---

Este objeto muestra imágenes de mapa de bits estáticas en la pantalla de video. La forma más sencilla de usar *roImagePlayer* es realizar llamadas a `DisplayFile()` con el nombre de archivo como un String. Alternativamente, puede usar `PreloadFile()` junto con `DisplayPreload()` para tener más control. Para obtener una estética más agradable al generar un reproductor de imágenes, use el objeto *roImageWidget* . El equivalente en JavaScript es la [etiqueta \<img> en HTML](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img).

Creación de objetos: El reproductor de imágenes se muestra creando primero instancias de *roRectangle* y *roImagePlayer* y luego llamando a `SetRectangle()` usando la instancia de *roRectangle* como argumento.

```text
rectangle = CreateObject("roRectangle", 0, 0, 1024, 768)
i = CreateObject("roImagePlayer")
i.SetRectangle(rectangle)
```

## ifImageControl 

### DisplayFile(image\_filename As String) As Boolean

Muestra la imagen con el nombre de archivo especificado. La cadena image\_filename debe apuntar a un archivo *.png*, *.jpeg*, o *.bmp* de 8 bits, 24 bits o 32 bits. Tenga en cuenta que los archivos de imagen *.jpeg* con perfiles de color CMYK no son compatibles.

### DisplayFile(parameters As roAssociativeArray) As Boolean

Muestra una imagen usando un arreglo asociativo de parámetros de visualización:

- `Nombre de archivo`: El nombre del archivo de imagen
- `Modo`: El modo de imagen. Consulte la entrada de SetDefaultMode() a continuación para obtener más detalles.
- `Transición`: La configuración de transición de la imagen. Consulte la entrada de SetDefaultTransition() a continuación para obtener más detalles.
- `AlgoritmoDeCifrado`: El algoritmo de cifrado de archivos. Actualmente las opciones son "AesCtr" y "AesCtrHmac".
- `ClaveDeCifrado`: La clave para descifrar el archivo de imagen. Este es un arreglo de bytes que consta de 128 bits de clave, seguidos de 128 bits de IV.

Consulte la sección [Descifrado de imágenes](docId\:z65qEZ0xwq9C70OBEgcYI) a continuación para obtener detalles sobre cómo mostrar imágenes cifradas.

:::hint{type="danger"}
&#x20;El reproductor de imágenes ya no acepta claves de cifrado AES "\{A|A}" (es decir, donde los 64 bits superiores e inferiores de la clave son idénticos).
:::

### PreloadFile(image\_filename As String) As Boolean

Carga el archivo de imagen especificado en un búfer de memoria fuera de pantalla.

### PreloadFile(parameters As roAssociativeArray) As Boolean

Carga un archivo de imagen en un búfer de memoria fuera de pantalla. Las propiedades de visualización de la imagen se determinan mediante un arreglo asociativo de parámetros:

- `Nombre de archivo`: El nombre del archivo de imagen
- `Modo`: Consulte la entrada de SetDefaultMode() a continuación para obtener más detalles.
- `Transición`: Consulte la entrada de SetDefaultTransition() a continuación para obtener más detalles.

### DisplayPreload() As Boolean

Usa el búfer de memoria en pantalla para mostrar la imagen almacenada en el búfer de memoria fuera de pantalla usando `PreloadFile()`. Solo hay dos búferes de memoria: uno se muestra en pantalla y el otro se usa para precargar imágenes. `PreloadFile()` puede llamarse varias veces antes de que se llame a `DisplayPreload()` y continuará cargando en el mismo búfer fuera de pantalla. El método `DisplayFile()` llama a `PreloadFile()` seguido inmediatamente por `DisplayPreload()`, por lo que cualquier imagen precargada previamente se perderá. Si no hay ninguna imagen precargada, `DisplayPreload()` no tendrá efecto.

### StopDisplay() As Boolean

Elimina una imagen de la pantalla.

### DisplayFileEx(filename As String, mode As Integer, x As Integer, y As Integer) As Boolean

### PreloadFileEx(filename As String, mode As Integer, x As Integer, y As Integer) As Boolean

### SetDefaultMode(mode As Integer) As Boolean

Establece el modo de visualización de imagen predeterminado para DisplayFile() y PreloadFile(). Si no se llama a SetDefaultMode(), el modo predeterminado se establece en 0 (equivalente a que la imagen se centre sin escalado). Los modos de visualización compatibles se enumeran a continuación:

- **0 – Centrar imagen**: No se aplica escalado. El recorte solo ocurre si la imagen es más grande que la ventana.
- **1 – Escalar para ajustar**: La imagen se escala para que sea completamente visible, manteniendo su relación de aspecto.
- **2 – Escalar para rellenar y recortar**: La imagen se escala para que rellene completamente la ventana, manteniendo su relación de aspecto.
- **3 – Escalar para rellenar**: La imagen se estira para que rellene la ventana y la imagen completa sea visible. La relación de aspecto no se mantendrá si es diferente de la ventana.

### SetDefaultTransition(transition As Integer) As Boolean

Establece la transición que se utilizará cuando se muestre la siguiente imagen. Las siguientes transiciones están disponibles:

- 0: Sin transición: blit inmediato
- 1-4: Barridos desde arriba, abajo, izquierda o derecha.
- 5-8: Explota desde el centro, la esquina superior izquierda, la esquina superior derecha, la esquina inferior izquierda o la esquina inferior derecha.
- 10-11: Utiliza un efecto de persiana veneciana vertical u horizontal.
- 12-13: Peina vertical u horizontalmente.
- 14: Se desvanece hasta el color de fondo y luego reaparece.
- 15: Realiza una transición gradual entre la imagen actual y la nueva imagen.
- 16-19: Se desliza desde arriba, abajo, izquierda o derecha.
- 20-23: Desliza toda la pantalla desde arriba, abajo, izquierda o derecha.
- 24-25: Escala la imagen antigua hacia dentro y luego la nueva hacia fuera nuevamente (esto funciona como una pseudorrotación alrededor de un eje vertical u horizontal).
- 26-29: Expande una nueva imagen en la pantalla desde la derecha, izquierda, abajo o arriba.

### SetTransform(transform As String) As Boolean

Aplica una de ocho transformaciones a la imagen. Las llamadas a este método solo tienen efecto cuando se muestra el siguiente archivo. Tenga en cuenta que el rectángulo de la imagen en sí no cambia para adaptarse a la nueva relación de altura y anchura de una imagen transformada. Este método se puede llamar por separado en varias instancias de *roImagePlayer* o *roImageWidget*.

- `identidad`: Sin transformación (comportamiento predeterminado)
- `rot90`: Rotación de 90 grados en sentido horario
- `rot180`: Rotación de 180 grados
- `rot270`: Rotación de 270 grados en sentido horario
- `espejo`: Transformación de espejo horizontal
- `mirror_rot90`: Rotación reflejada de 90 grados en sentido horario
- `mirror_rot180`: Rotación reflejada de 180 grados en sentido horario
- `espejo_rot270`: Rotación reflejada de 270 grados en sentido horario

### OverlayImage(image\_filename As String, x As Integer, y As Integer) As Boolean

Compone la imagen con el nombre de archivo especificado sobre la imagen principal de `DisplayFile()` . Utilice los enteros `x` y `y` para especificar su ubicación dentro del widget de imagen.

### SetRectangle(r As roRectangle) As Boolean

Cambia el tamaño y la posición del rectángulo de imagen utilizando el objeto *roRectangle*.

### GetRectangle() As roRectangle

Devuelve un objeto *roRectangle* que tiene la misma ubicación y dimensiones que el objeto *roRectangle* utilizado para definir la ventana de imagen.

### CreateTestHole(hole As roRectangle) As Boolean

Crea un agujero en la imagen con la ubicación y las dimensiones especificadas en la instancia de *roRectangle* pasada. Cualquier ventana de video ubicada directamente debajo de la imagen se mostrará a través de ella. Este método interrumpirá la reproducción de imágenes y solo debe usarse con fines de prueba.

### SetTransitionDuration(duration As Integer) As Boolean

Establece la cantidad de tiempo que tarda (en milisegundos) en producirse un efecto de transición especificado. La duración predeterminada de la transición es de 1000 milisegundos.

### DisplayBuffer(a As Object, b As Integer, c As Integer) As Boolean

### Hide() As Boolean

Oculta la imagen que se muestra actualmente mediante el widget *roImagePlayer*.

### Show() As Boolean

Muestra la imagen que se está mostrando actualmente mediante el widget *roImagePlayer*.

### Raise() As Void

Envía el widget a la parte superior del orden z en el plano gráfico (es decir, delante de todas las demás superficies que implementan la interfaz *ifWidget*). De forma predeterminada, los widgets nuevos se colocan en la parte superior del orden z gráfico.

:::hint{type="info"}
Algunas superficies siempre se dibujan en la parte superior del orden z gráfico, incluidos el cursor del mouse, los subtítulos ocultos y los [marquesinas desplazables](docId:2PWSmk6GFbdKC8rtFzKfj).
:::

:::hint{type="success"}
Puede usar los métodos `PauseGraphics()`/ `ResumeGraphics()` en el objeto [roVideoMode](#) para garantizar que varios cambios en el orden z gráfico se produzcan simultáneamente.
:::

### Lower() As Void

Envía el widget a la parte inferior del orden z en el plano gráfico (es decir, detrás de todas las demás superficies que implementan la interfaz *ifWidget*). De forma predeterminada, los widgets nuevos se colocan en la parte superior del orden z gráfico.

## X, Y

Los valores x e y indican qué posición de la imagen se debe centrar lo más cerca posible, o tanto x como y pueden establecerse en -1, lo que utiliza el centro de la imagen como el punto que se posicionará más cerca del centro.

Para mostrar imágenes en una zona, se debe llamar a `SetRectangle()` y `EnableZoneSupport()` debe incluirse en un script para usar la funcionalidad de zonas.

## Prueba de modos de visualización

A continuación se muestran algunos comandos de shell de ejemplo que puede usar para probar los diferentes modos de visualización:

```text
BrightSign> image filename.bmp 0
BrightSign> image filename.bmp 1
BrightSign> image filename.bmp 2
BrightSign> image filename.bmp 3

BrightSign> image filename.bmp 0 0 0
BrightSign> image filename.bmp 2 0 0
```

## Precarga de imágenes

El siguiente script de ejemplo utiliza imágenes precargadas para mejorar la velocidad de la interfaz de usuario cuando el usuario presiona una tecla en el teclado. Tan pronto como se presiona una tecla, la pantalla cambia a la nueva imagen, que ya se ha precargado. El único retraso posible ocurre si la tecla se presiona mientras la imagen se está precargando. En este caso, la imagen se mostrará tan pronto como se cargue.

```text
i = CreateObject("roImagePlayer")
p = CreateObject("roMessagePort")
k = CreateObject("roKeyboard")
k.SetPort(p)

i.PreloadFile("one.bmp")

loop:
i.DisplayPreload
i.PreloadFile("two.bmp")
Wait(0,p)
i.DisplayPreload
i.PreloadFile("one.bmp")
Wait(0,p)
goto loop
```

## Descifrado de imágenes 

Los objetos *roImagePlayer*, *roImageWidget*, *roClockWidget*, *roTextWidget*, y *roCanvasWidget* pueden usarse para mostrar imágenes cifradas. Cada objeto tiene un método de reproducción de imágenes que acepta una matriz asociativa, que puede incluir los parámetros de descifrado `EncryptionAlgorithm` y `EncryptionKey`.

:::hint{type="info"}
Póngase en contacto con [support@brightsign.biz](mailto\:support@brightsign.biz) para obtener más información sobre cómo generar una clave para ofuscación y almacenarla en el reproductor.
:::

Puede llamar a `roDeviceInfo.HasFeature("media_decryption")` para determinar si un modelo de reproductor y una versión de firmware admiten el descifrado de imágenes.

Ejemplo:

```text
print "Play ENCRYPTED image in an image widget"

imagePlayer = CreateObject("roImageWidget", r1)

aa=CreateObject("roAssociativeArray")
aa.filename = "sd:/images_enc.jpg"
aa.encryptionalgorithm = "AesCtr"
aa.encryptionkey = CreateObject("roByteArray")
aa.encryptionkey.fromhexstring("01030507090b0d0f00020406080a0c0e00000000000000000000000000000000")

imagePlayer.DisplayFile(aa)
sleep(10000)
imagePlayer.Hide()

print "Play ENCRYPTED image with PlayStaticImage"

videoPlayer = CreateObject("roVideoPlayer")

aa=CreateObject("roAssociativeArray")
aa.filename = "sd:/images_enc.jpg"
aa.encryptionalgorithm = "AesCtr"
aa.encryptionkey = CreateObject("roByteArray")
aa.encryptionkey.fromhexstring("01030507090b0d0f00020406080a0c0e00000000000000000000000000000000")

videoPlayer.PlayStaticImage(aa)
sleep(10000)
videoPlayer = invalid

print "Show CLOCK image"

resourceManager = CreateObject("roResourceManager", "sd:/resources.txt")

clockWidget = CreateObject("roClockWidget", r1, resourceManager, {})

aa=CreateObject("roAssociativeArray")
aa.filename = "sd:/images_enc.jpg"
aa.encryptionalgorithm = "AesCtr"
aa.encryptionkey = CreateObject("roByteArray")
aa.encryptionkey.fromhexstring("01030507090b0d0f00020406080a0c0e00000000000000000000000000000000")

clockWidget.SetBackgroundBitmap(aa, True)
clockWidget.Show()
sleep(10000)
clockWidget.Hide()

print "Text widget with encrypted background image"

twParams = CreateObject("roAssociativeArray")
twParams.LineCount = 1
twParams.TextMode = 1
twParams.Rotation = 0
twParams.Alignment = 1

tw=CreateObject("roTextWidget",r1,1,2,twParams)
tw.SetBackgroundColor(&h00ff0000)
tw.SetForegroundColor(&hff00ff00)
tw.PushString("Encrypted Background")
'tw.SetRectangle(r)

aa=CreateObject("roAssociativeArray")
aa.filename = "sd:/images_enc.jpg"
aa.encryptionalgorithm = "AesCtr"
aa.encryptionkey = CreateObject("roByteArray")
aa.encryptionkey.fromhexstring("01030507090b0d0f00020406080a0c0e00000000000000000000000000000000")

tw.SetBackgroundBitmap(aa, True)
tw.Show()
sleep(10000)
tw.Hide()

cw=CreateObject("roCanvasWidget", rect)
canvas_aa=CreateObject("roAssociativeArray")
canvas_aa.Filename = "sd:/images_enc.jpg"
canvas_aa.Encryptionalgorithm = "AesCtr"
canvas_aa.EncryptionKey = CreateObject("roByteArray")
canvas_aa.EncryptionKey.FromHexString("01030507090b0d0f00020406080a0c0e00000000000000000000000000000000")
cw.SetLayer(canvas_aa, 1)
cw.Show() 
```