Skip to content

Benchmarks

How we benchmark an IPTV player, and how to test any player yourself

Every IPTV player says it is fast. We wanted a number we could check after every change, on the kind of TV people really own. This is the test, the results, what turned out to be noise, and the commands to run it on any player you like.

By the MuskTV team · · 9 min read

In short

  • We measure six things on a budget Android 11 TV with under 1 GB of RAM, playing a 1080i H.264 sports channel: cold start, channel switch time, CPU, memory, video frame timing and guide scrolling.
  • MuskTV's results: opens in about 0.66 s, switches channels in about 1.1 s, uses 23–32% CPU and 70–95 MB of memory while playing.
  • Against TiviMate on a 1 GB Android TV emulator (three alternating passes): MuskTV opened in 224 ms against 612 ms and used 71 MB against 98 MB. Playback was level.
  • The test uses only standard Android tools (adb, am start -W, dumpsys), so you can run the same commands against any IPTV player on your own device.

The test device: a TV that struggles

A fast phone or a $200 streaming box hides almost every performance problem. So the benchmark runs on the weakest device we own: a budget smart TV with Android 11, a low-end TV chip, about 900 MB of RAM and a 1280×720 interface at 60 Hz. It is the same class of hardware as a cheap Android box or an entry-level Fire TV Stick.

The test stream is a real broadcast: a 1080i H.264 sports channel at roughly 8.5 Mbps, 25 frames per second. Interlaced sport is about the hardest thing a small TV chip is asked to play, which makes it a good stress test.

The channel comes from our own TV provider's playlist. MuskTV is a player only: it does not include channels, and the benchmark does not depend on any particular provider.

The six measurements

The whole run is one script that presses the remote's buttons over adb and reads Android's own counters. It takes about three minutes. Nothing is measured inside the app, so the same script works on any player.

MeasurementHow it is takenWhy it matters
Cold startThe app is force-stopped, then started with am start -W. Android reports TotalTime in milliseconds. Median of 3 starts.How long you look at a blank screen after pressing the app icon.
Channel switchChannel-up is pressed 5 times, 8 seconds apart. For each press we add up the time the video surface showed no new frame. Median of 5.The pause every time you zap. It is the number you feel most.
CPU while playingtop for the app's process, 5 samples 2 seconds apart, averaged, with the channel full screen.A busy CPU means heat, dropped frames and a slow menu on a weak chip.
Memorydumpsys meminfo, the TOTAL PSS line, while playing.On a 1 GB device the system closes the app that uses the most memory.
Frame timing30 seconds of video frame times from dumpsys SurfaceFlinger --latency: real frames per second, the share of frames more than 60 ms apart, and the worst gap.This is stutter, measured where the picture reaches the screen.
Guide scrollingdumpsys gfxinfo is reset, the script scrolls 30 rows of the TV guide, then reads janky frames and the 50th and 90th percentile frame time.Whether the guide moves smoothly while video plays in the corner.

MuskTV's results

These are saved runs of three public versions on that TV. A new run is compared with the median of the last five; anything 10% or more worse is flagged and has to be explained or fixed before release.

Measurement0.1.00.2.00.3.0
Cold start655 ms635 ms676 ms
Channel switch (median)1.06 s1.10 s1.12 s
CPU while playing 1080i23%26%24%
Memory (PSS)87 MB88 MB94 MB
Frames per second252525
Guide scroll, median frame10 ms9 ms10 ms
MuskTV on a budget Android 11 TV with under 1 GB of RAM, 1080i H.264 channel, October 2026. The app is 2.4 MB.

Three versions and dozens of features later the numbers have barely moved. That is the point of the test: remote shortcuts, search, catch-up, a sleep timer and channel management were all added without making the app slower to open or to zap.

How it gets there is not a secret: video is decoded by the TV's video chip instead of the CPU, live buffers are kept small, each channel switch gets a fresh decoder, and the TV guide is read as a stream instead of being loaded into memory. More on that on the lightweight IPTV player page.

Where a one-second channel switch goes

We timed 40 switches with extra logging to see what the second is spent on. From the key press to the moment MuskTV asks the player to start: 10–11 ms. Everything else, about 1.1 to 1.3 seconds, is the provider's server answering with the playlist and the first video segments, and the TV's decoder starting.

We also tried halving the start buffer from 1 second to 500 ms. The difference was inside the measurement error (1157 ms against 1192 ms, ±100 ms), so the safer 1 second stayed. The lesson for anyone comparing players: below about a second, channel switch time is mostly your provider and your device, not the app.

What turned out to be noise

The first weeks of benchmarking taught us more about measuring than about the app. If you test players yourself, expect these:

  • CPU follows the broadcast. The same build measured between 24.5% and 34.1% within 16 minutes, because a fast-moving match is harder to decode than a studio shot. Compare two builds or two players only by alternating them several times and taking the median.
  • Memory moves by itself. PSS on one build ranged from 71 to 94 MB between runs. The Java and native heaps were identical; the difference was shared system code pages and how much of the guide happened to be loaded.
  • A 60 Hz screen cannot show 25 fps evenly. On this TV 10–15% of frames arrive "late" in every player we have tried, because 25 does not divide into 60. Watch for a change in that number, not the number itself.
  • Guide scrolling depends on the TV's graphics chip. Janky frames ranged from 18% to 33% on the very same build. One run proves nothing; twelve alternating runs do.

So the rule is: a single run is a smoke alarm, not a verdict. When a number looks worse we install both builds side by side and run them alternately before deciding.

Does it compare with other players?

Once, by hand, in October 2026, we ran the same measurements on a mature, widely used IPTV player on the same TV and the same channel. We are not naming it: one session on one TV is not a fair review of anyone's product. But here is what the session showed, with the noise above in mind:

MeasurementMuskTVThe other playerOutside the noise?
Guide scroll, janky frames13%92–93%Yes, by a wide margin
Guide scroll, median frame8 ms28–30 msYes
CPU while playingabout 30%about 46%Probably: above the 24–34% range we see for MuskTV
Memory (PSS)94 MB105 MBNo
Channel switchabout 1.0 sabout 1.2 s, with a flash between channelsThe time, no. The flash is visible.
Frames per second2525Same
One hand-measured session, same TV, same 1080i channel, 29 October 2026.

The honest summary: on a weak TV both players show the picture equally well. The difference is in everything around the picture, mainly how the guide moves while video is playing. That is where a 1 GB device runs out of headroom first, and it is what MuskTV was built around.

That session is why we later repeated the test in a way that can be named and copied: the next section.

A named comparison: MuskTV and TiviMate on a 1 GB emulator

In November 2026 we ran the script against a player we can name, in a setup anyone can copy: the Android TV 12 emulator from Android Studio, limited to 1 GB of RAM and 2 CPU cores. Both players had the same provider playlist. We ran three passes of each, alternating, with the other player force-stopped during each pass, and took the median.

MeasurementMuskTV 0.4.0TiviMate 5.3.3Outside the noise?
Cold start224 ms (194–268)612 ms (588–704)Yes: the ranges do not overlap
Memory while playing (PSS)71 MB (70–72)98 MB (95–107)Yes: the ranges do not overlap
Guide scroll, 90th percentile frame17 ms (12–17)32 ms (32–40)Yes, but both scrolled without a janky frame
Guide scroll, median frame16 ms17 msNo
CPU while playing8% (4–15)9% (8–24)No
Frames per second2525Same
Medians of three alternating passes (range in brackets), Android TV 12 emulator with 1 GB RAM and 2 cores, 16 November 2026.

What this shows: MuskTV opens in about a third of the time and uses about 27 MB less memory. In playback itself the two are level: the same frame rate and no CPU difference we can separate from noise.

  • It is an emulator. Video is decoded by the computer, not by a TV chip, and the host is far faster than a budget TV, so absolute numbers are better than on real hardware. On our 1 GB TV MuskTV's cold start is about 660 ms, not 224.
  • Channel switch time is missing for TiviMate because the script's channel-up key does not change channel there. MuskTV's median was 719 ms.
  • The channel played was not verified to be the same in both players (they number channels differently), which is one more reason to ignore the CPU row.
  • The guides were not equally full. MuskTV had programme data loaded; the rows TiviMate showed during the run had none.
  • TiviMate does things MuskTV does not, such as recording, multi-view and several playlists. This test measures speed and memory, nothing else.

Run the test on any IPTV player

You need a computer with adb (Android platform-tools) and a TV, box or Fire TV with ADB debugging turned on in Developer options. Connect with the device's IP address, then find the package name of the player you want to test.

adb connect 192.168.1.50:5555
adb shell pm list packages -3        # installed apps; pick the player's package
  1. Cold start. Run the two commands below three times and take the middle TotalTime. Replace PACKAGE with the player's package name.
  2. CPU. Start a channel full screen, wait 20 seconds, then run the top line a few times. The %CPU column is per core: 100% means one full core.
  3. Memory. While the channel is still playing, run the meminfo line and read TOTAL PSS (in kB).
  4. Guide scrolling. Open the player's TV guide, run the gfxinfo reset line, scroll 30 rows with the remote, then run the last line and read Janky frames and the 50th / 90th percentile.
  5. Repeat. Do the whole thing again on the second player, then once more on each. Use the same channel at the same time of day, and compare medians.
# 1. cold start
adb shell am force-stop PACKAGE
adb shell monkey -p PACKAGE -c android.intent.category.LEANBACK_LAUNCHER 1   # or: am start -W -n PACKAGE/ACTIVITY

# 2. CPU while playing
adb shell top -b -n 1 | grep PACKAGE

# 3. memory while playing
adb shell dumpsys meminfo PACKAGE | grep "TOTAL PSS"

# 4. guide scrolling
adb shell dumpsys gfxinfo PACKAGE reset
#    ...scroll 30 rows...
adb shell dumpsys gfxinfo PACKAGE | grep -E "Janky frames|50th|90th"

am start -W -n PACKAGE/ACTIVITY prints TotalTime directly; adb shell cmd package resolve-activity --brief PACKAGE shows the activity name to use. The monkey line starts the app without knowing the activity, but then you time it by eye.

To test MuskTV the same way, install it from the download page: the package name is com.musktv.tv. The 7-day trial has every feature, so the numbers you get are the numbers of the paid app.

What this benchmark does not tell you

  • It is one TV. A different chip, Android version or screen will give different absolute numbers; the order between two players usually holds, the size of the gap may not.
  • It measures speed, not features. A player can be quick and still miss something you need. MuskTV, for example, plays one playlist at a time and has no recording yet; the features page lists what it does today.
  • It cannot fix a slow provider. Buffering that comes from the server or the network looks the same in every player. See why IPTV buffers and how to fix it.
  • The phone app is not covered. These numbers were measured on a TV with the TV app.

Questions

Is MuskTV the fastest IPTV player?

We can only vouch for what we measured: on a budget Android 11 TV with under 1 GB of RAM it opens in about 0.66 seconds, switches channels in about 1.1 seconds and uses 23–32% CPU playing a 1080i channel. The test uses standard Android tools, so you can run it against any other player on your own device and compare.

What tools do you need to benchmark an IPTV player?

Only adb from Android platform-tools and a device with ADB debugging turned on. Cold start comes from "am start -W", CPU from "top", memory from "dumpsys meminfo" and scrolling smoothness from "dumpsys gfxinfo".

Why does changing channel take about a second in every IPTV player?

Most of that second is the provider's server sending the playlist and the first video segments, plus the device's decoder starting. In our instrumented test MuskTV's own code took 10–11 ms of it.

How much RAM does an IPTV player need?

It depends on the player. MuskTV used 70–95 MB while playing a 1080i channel with a full TV guide loaded, which leaves room on a device with 1 GB of RAM.