Drive an LED video wall from an Android signage player

What does an Android signage player actually send to an LED wall?

It sends one fixed HDMI frame from its HDMI output into the sender card, almost always 1920 x 1080 pixels, and the wall's size in metres never reaches the player at all. The player composites its layouts on the Android side at the resolution you set for it in the CMS, then hands that picture over HDMI exactly as a laptop would. The sender card decides which rectangle of the incoming frame lands on which cabinets.

Two consequences follow. First, set the player resolution to the sender's input format, not to the wall's pixel count. Second, author the layout on a canvas at that same frame size, and place the wall's picture in it as a region whose pixel count matches the wall. Get both mappings right and the wall behaves like any other screen. Get them wrong and you see a cropped corner of the layout, or a soft picture that has been rescaled twice.

What do you need before you start?

You need four numbers and one cable: the wall's pixel count in pixels, the sender card's accepted input format, usually 1920 x 1080 at 60 Hz, the player resolution setting in your CMS, and a short HDMI lead between player and sender. Gather these before anyone climbs a ladder.

• The panel specification sheet, with pitch in mm and cabinet size in mm, so the pixel count is a multiplication, not a guess.
• The sender card or controller model, with its configuration software on a laptop. Input format and screen mapping live there.
• A player: a small Android signage box, or one of our panel screens running the free signage player, which plays images and MP4 video from a microSD or USB card with no subscription.
• The show itself on a card, prepared so it starts on its own at power-on; offline playlist autostart on a signage screen covers that setup.
• One HDMI lead, kept short. Long runs need an extender that passes the format unchanged, so test it before mounting.

How do you find the wall's real pixel count?

Multiply the number of cabinets by the pixels per cabinet from the panel's specification sheet: a 500 x 500 mm cabinet at 3.91 mm pitch carries 128 x 128 pixels, and a 768 x 768 mm cabinet at 3 mm pitch carries 256 x 256 pixels. Pitch is the centre-to-centre distance between pixels in millimetres, so pixels per cabinet are the cabinet side divided by the pitch, and the sheet normally prints the result anyway. Count the cabinets in each direction, multiply, and you have the width and height in pixels the sender software asks for. From here the CMS only understands pixels: author the template in pixels and keep the metre marks of the site plan out of the layout.

How do you set it up, step by step?

Set every stage to the same 1920 x 1080 frame, then map the wall's pixels onto a window of that frame in the sender's control software and build one layout region to match, in that order.

1. Set the sender's input format to 1920 x 1080 at 60 Hz in its configuration software.
2. Enter the wall's pixel count and set the screen mapping to 1:1 with no scaling. Note the window position the software reports; the worked example below shows the arithmetic.
3. Set the player resolution to 1920 x 1080 in the CMS, so the picture it composites is the picture the sender expects. Some Android boxes carry a screen-resolution setting in the system settings as well.
4. Build the layout template on a 1920 x 1080 canvas.
5. Give each physical wall surface its own region at that surface's true pixel count, placed at the same offset as the sender's window. One wall face is one region; a three-face vehicle build is three regions in one template.
6. Load the show on the card and set the player as the home app, so the show comes up full screen by itself at power-on.
7. Set brightness levels and any brightness schedule for the wall in the sender's software. The player's own daily on and off times control only the picture it sends.

What files should you load on the card?

Load JPG, PNG or WebP for slides and MP4 with H.264 for video, and leave PowerPoint, PDF, HEIC and GIF off the card, because the player does not play them. Size slide text from the pixel pitch: 1 pixel at 3.91 mm pitch is 3.91 mm on the wall, and the worked example below turns that into a capital height and a reading distance. For video, test the bitrate with a short clip before committing the whole show; video bitrate for signage players covers the test. Slides crossfade by default and the fade can be set up to 5 seconds, which suits a wall read from far off.

How do you check the show is mapped correctly?

Send a full-white test slide with a 1 pixel black border and tick marks, and confirm the marks land sharp on the wall's outer pixels while the player reports 1920 x 1080. Make the test slide at 1920 x 1080 with tick marks every 100 pixels; a full white field also exposes a dead cabinet line before opening day. If the picture lands soft, the sender is scaling, so go back to the 1:1 window and the region offset. If the player's settings say 1080p but the picture still arrives soft or shifted, some Android boxes composite internally at a smaller framebuffer than the output suggests, and why a portrait signage player reports 720p framebuffer resolution shows how to spot that. Finish by cutting power for ten seconds and letting both boxes come back: the player is designed to bring the show up full screen on its own, and the wall should return with it.

What does a 6 x 3 m example look like in numbers?

A 6 m x 3 m wall built from twelve by six 500 mm cabinets at 3.91 mm pitch is 1536 x 768 pixels, which is 1,179,648 pixels in total and needs two sending ports at the usual 650,000 pixel loading. The arithmetic, cabinet by cabinet: 6000 mm / 500 mm = 12 cabinets wide, 3000 mm / 500 mm = 6 cabinets tall, each cabinet 128 x 128 pixels, so 12 x 128 = 1536 pixels wide and 6 x 128 = 768 pixels tall, a total of 1536 x 768 = 1,179,648 pixels. One sending port carries about 650,000 pixels at 60 Hz with 8-bit colour, the common planning figure quoted for one output port, so one port falls short; two ports carry 1,300,000 pixels and take the wall with margin.

The frame mapping follows: 1536 x 768 sits inside 1920 x 1080 with 1920 - 1536 = 384 pixels spare horizontally and 1080 - 768 = 312 vertically, so a centred 1:1 window starts (1920 - 1536) / 2 = 192 pixels from the left and (1080 - 768) / 2 = 156 pixels from the top. The template region matches: 1536 x 768 at position 192, 156, and every pixel in the file lands on exactly one LED pixel.

Text sizing falls out of the same pitch. A capital 26 pixels tall is 26 x 3.91 mm = 102 mm, about 10 cm. By the 30 ft of viewing distance per inch of capital height planning figure (FHWA) set out in our screen size and viewing distance guide, that reads from about 36 m, or about 24 m at the safer 20 ft per inch.

The same physical wall at 10 mm pitch is 6000 / 10 = 600 by 3000 / 10 = 300 pixels, 180,000 in total, one port with room to spare. The metres never changed; the pixels did, and every decision above follows the pixels.

When is an Android player the wrong sender?

Choose a different source when the wall's pixel count climbs past what a 1080p frame or the port loading can carry: above 2,073,600 pixels the wall cannot be filled 1:1 from 1920 x 1080, and a true 4K source takes over. The frame is the hard limit, since 1920 x 1080 carries exactly 2,073,600 pixels; large media facades and very fine pitch walls cross that line and want a sender that accepts 3840 x 2160 input with a source that genuinely outputs it. Do not author a 4K canvas on a 1080p output and hope; why a 4K portrait signage player shows a quarter of the layout shows what happens to the geometry when canvas and output disagree. Multi-surface jobs stay in scope: three faces on one vehicle are three regions in one template, the same pattern as one Android signage player driving multiple displays.

Recommendation: Run the whole chain at 1920 x 1080. Set the sender's input format to 1920 x 1080 at 60 Hz, set the player resolution to 1920 x 1080 in the CMS, author the template on a 1920 x 1080 canvas, and give every wall surface a region at its true pixel count behind a 1:1 sender window. Use this setup when the wall's pixel count fits inside 2,073,600 pixels and under about 650,000 pixels per sending port at 60 Hz; move to a 4K sender and a true 4K source once the count passes either line.

Questions