# How SmartTube Manages Video Quality Presets: A Complete Technical Guide

> Discover how SmartTube manages video quality presets using a technical deep dive into AppDataSourceManager and ExoPlayer integration. Learn about preset filtering, rendering, and application.

- Repository: [Yuriy L/SmartTube](https://github.com/yuliskov/SmartTube)
- Tags: deep-dive
- Published: 2026-09-14

---

**SmartTube manages video quality presets through a static array of `VideoPreset` objects defined in `AppDataSourceManager`, filters them by device capability using `Utils.isPresetSupported()`, renders them via `AppDialogUtil.createVideoPresetsCategory()`, and applies them to ExoPlayer by parsing spec strings into track selection parameters.**

SmartTube, the popular open-source YouTube client for Android TV developed by yuliskov, implements a sophisticated video quality preset system that allows users to force specific resolutions, frame rates, and codecs. The architecture cleanly separates preset definition, hardware validation, UI presentation, and playback integration to ensure users only see compatible options while maintaining full control over the streaming experience.

## How SmartTube Defines Video Quality Presets

### The VideoPreset Data Structure

At the core of the system is the **`VideoPreset`** class, an inner class of `FormatItem` that acts as a lightweight container for display names and technical specifications. Each preset holds a human-readable label and a machine-parseable format string.

```java
// From FormatItem.java - VideoPreset inner class
public VideoPreset(String presetName, String presetSpec) {
    this.name = presetName;
    this.format = presetSpec;
}

```

The format spec uses a comma-delimited structure: `width,height,fps,codec[.hdr]`. For example, `"1280,720,60,av01.hdr"` represents 720p resolution at 60 frames per second using the AV1 codec with HDR enabled.

### Static Preset Definitions in AppDataSourceManager

The complete catalog of available presets lives in **[`AppDataSourceManager.java`](https://github.com/yuliskov/SmartTube/blob/main/AppDataSourceManager.java)** (lines 82-142), where a static array defines every supported combination from 144p 30fps AVC to 4K 60fps AV1 HDR.

```java
// AppDataSourceManager.java - lines 82-142
public VideoPreset[] getVideoPresets() {
    return new VideoPreset[] {
        new VideoPreset("720p     60fps    av01+hdr", "1280,720,60,av01.hdr"),
        new VideoPreset("1080p    60fps    av01+hdr", "1920,1080,60,av01.hdr"),
        new VideoPreset("4K       30fps    av01+hdr", "3840,2160,30,av01.hdr"),
        new VideoPreset("4K       60fps    av01+hdr", "3840,2160,60,av01.hdr"),
        // ... additional presets
    };
}

```

This centralized definition makes it straightforward to add new formats as hardware capabilities evolve or YouTube expands codec support.

## Filtering Presets by Device Capability

Before displaying presets to users, SmartTube validates hardware compatibility to prevent selection of unsupported formats. The **`Utils.isPresetSupported()`** method (lines 833-838 in [`Utils.java`](https://github.com/yuliskov/SmartTube/blob/main/Utils.java)) checks whether the device can decode VP9 or AV1 at the requested resolution.

```java
// Utils.java - lines 833-838
public static boolean isPresetSupported(VideoPreset preset) {
    // Validates VP9/AV1 codec support and resolution limits
    // Returns false if device cannot render the specified format
    return isCodecSupported(preset.format) && 
           isResolutionSupported(preset.format);
}

```

This filtering occurs during UI generation, ensuring that budget Android TV devices only see AVC (H.264) options while high-end streamers get access to AV1 and VP9 selections.

## Rendering the Preset Selection UI

### Building the Settings Dialog

The **`AppDialogUtil`** class provides the bridge between data and presentation. The **`createVideoPresetsCategory()`** method (lines 261-289 in [`AppDialogUtil.java`](https://github.com/yuliskov/SmartTube/blob/main/AppDialogUtil.java)) constructs a settings category that integrates with the app's preference system.

```java
// AppDialogUtil.java - lines 261-289
public static OptionCategory createVideoPresetsCategory(...) {
    List<OptionItem> options = fromPresets(presets, playerData, onSelected);
    return OptionCategory.from(PRESETS_ID, R.string.video_presets, options);
}

```

### Creating Selectable Options

The helper method **`fromPresets()`** iterates over the filtered preset array and generates `OptionItem` instances with selection callbacks. Each item triggers the format application when tapped.

```java
// Inside fromPresets() - AppDialogUtil.java
OptionItem item = UiOptionItem.from(
    preset.name,
    option -> setFormat(preset.format, playerData, onFormatSelected),
    isSelected
);

```

Both **`PlayerSettingsPresenter`** and **`HQDialogController`** utilize this utility to inject preset selection into the Settings screen and the "High-Quality" quick dialog respectively.

## Applying a Preset to ExoPlayer

### Parsing the Spec String

When a user selects a preset, the system converts the format string into an **`ExoFormatItem`** through the **`fromVideoSpec()`** factory method. This parses the comma-separated values into structured width, height, frame rate, codec, and HDR parameters.

```java
// Example: Selecting "720p 60fps av01 HDR"
String presetSpec = "1280,720,60,av01.hdr";
ExoFormatItem format = ExoFormatItem.fromVideoSpec(presetSpec, true);

```

### Forcing the Track Selection

The parsed format overrides the ExoPlayer track selector parameters, forcing the renderer to choose streams matching the preset criteria rather than adaptive bitrate selection.

```java
// Inside setFormat() callback - AppDialogUtil.java line 293
player.getTrackSelector().setParameters(
    player.getTrackSelector().buildUponParameters()
          .setPreferredVideoFormat(format.toExoFormat())
);

```

This mechanism works identically whether applied through user interaction or automatically during app startup.

## Persisting User Selection

SmartTube stores the selected preset index using the **`VIDEO_PRESET_INDEX`** preference key. On application initialization, the player reads this saved index, retrieves the corresponding preset from `AppDataSourceManager`, and executes the same `setFormat()` path to restore the user's preferred quality settings without requiring manual reselection.

## Summary

- **Centralized Definitions**: All video quality presets are defined as static `VideoPreset` objects in [`AppDataSourceManager.java`](https://github.com/yuliskov/SmartTube/blob/main/AppDataSourceManager.java) (lines 82-142) using comma-separated spec strings.
- **Hardware Validation**: The `Utils.isPresetSupported()` method filters presets by checking VP9/AV1 decoding capabilities at specific resolutions.
- **UI Generation**: `AppDialogUtil.createVideoPresetsCategory()` generates selectable options that appear in both `PlayerSettingsPresenter` and `HQDialogController`.
- **Format Application**: Preset strings are parsed by `ExoFormatItem.fromVideoSpec()` and applied to ExoPlayer's track selector to force specific video formats.
- **State Persistence**: Selected presets are saved via the `VIDEO_PRESET_INDEX` preference and automatically applied on app startup.

## Frequently Asked Questions

### How does SmartTube prevent users from selecting unsupported 4K or AV1 presets?

SmartTube validates device capabilities through `Utils.isPresetSupported()` (lines 833-838 in [`Utils.java`](https://github.com/yuliskov/SmartTube/blob/main/Utils.java)) before displaying options. This method checks whether the Android TV hardware can decode VP9 or AV1 codecs at the requested resolution, filtering out impossible formats such as 4K AV1 on devices with limited graphics pipelines.

### What happens when I select a video quality preset in the settings?

When selected, the preset string (e.g., `"3840,2160,60,av01.hdr"`) is parsed by `ExoFormatItem.fromVideoSpec()` into a structured format object. This is passed to ExoPlayer's `DefaultTrackSelector` via `setPreferredVideoFormat()`, which forces the player to select video tracks matching your specified resolution, frame rate, codec, and HDR settings rather than using adaptive streaming.

### Where are the video quality presets defined in the source code?

All presets are statically defined in [`AppDataSourceManager.java`](https://github.com/yuliskov/SmartTube/blob/main/AppDataSourceManager.java) between lines 82 and 142 as an array of `VideoPreset` objects. Each entry combines a display name (like "4K 60fps av01+hdr") with a technical specification string that ExoPlayer parses to configure the video renderer.

### Can I add custom video quality presets to SmartTube?

While the preset array is static in [`AppDataSourceManager.java`](https://github.com/yuliskov/SmartTube/blob/main/AppDataSourceManager.java), developers can extend the `getVideoPresets()` method to include additional `VideoPreset` entries following the `width,height,fps,codec[.hdr]` format. However, unsupported combinations will be filtered out by `Utils.isPresetSupported()` unless the device hardware capabilities are also satisfied.