Video Playback

Microsoft::Xna::Framework::Media — VideoPlayer, Video, FFmpeg-backed frame decoding

Overview

VideoPlayer and Video live in the Microsoft::Xna::Framework::Media namespace, matching the XNA 4.0 API. CNA uses FFmpeg as its video decoding back-end: the decoder reads compressed frames from the container, converts them from YUV colour space to RGBA, and uploads the result as a Texture2D. Your Draw() method retrieves that texture each frame via VideoPlayer::GetTexture() and renders it with SpriteBatch (or any other drawing path) exactly like any other Texture2D.

This is a real decoder, and it is no longer the only implemented part of Media. MediaPlayer genuinely plays songs, while MediaLibrary resolves the user's music and pictures directories, scans them recursively, parses common audio tags and playlists, discovers album art, and persists pictures. Treat individual device/library behaviors as platform-dependent rather than as a Windows Phone or Zune service emulation.

Frame timing is driven by the stream's own presentation timestamps rather than by a fixed frame counter, so playback tracks the container's real timeline instead of drifting against it.

Supported container and codec combinations:

• MP4 — H.264 / H.265
• OGV — Ogg Theora
• WEBM — VP8 / VP9
• MKV — Matroska (any FFmpeg-supported codec)
• AVI — legacy container
• MOV — QuickTime container

Video Class

A Video object represents a video asset loaded from disk. Load it through the standard ContentManager pipeline:

// LoadContent()
auto video = content.Load<Video>("videos/intro");

The ContentManager resolves the file extension automatically; the path should be relative to the content root and omit the extension. Once loaded, the following read-only properties are available:

VideoPlayer Class

VideoPlayer controls playback of a Video asset. Create one instance per active video stream; it is not designed for concurrent playback of multiple videos from the same instance.

Methods

Properties

Rendering Pattern

VideoPlayer decodes frames on demand rather than pre-decoding the entire video. On each call to GetTexture(), CNA checks whether the elapsed playback time requires a new frame to be decoded, converts the YUV output to RGBA, and uploads it to the GPU as a Texture2D. This means the texture pointer returned by GetTexture() is stable for the lifetime of the player, but its contents are updated in-place each frame.

The recommended pattern inside Draw():

1. Call player.GetTexture() to obtain the current frame as a Texture2D*.
2. If the pointer is non-null, draw it with SpriteBatch::Draw() scaled to the desired screen rectangle.

Platform Availability

FFmpeg Setup

FFmpeg is an optional, desktop-Linux-only dependency, located through pkg-config at configure time. It must be installed on the host system before building CNA with video support; if it is absent, CNA builds fine and video is simply unavailable.

On Debian and Ubuntu:

sudo apt install libavcodec-dev libavformat-dev libavutil-dev libswresample-dev libswscale-dev

The decoder is built on libavcodec (codec implementations), libavformat (container demuxers) and libswresample (audio resampling), alongside the usual FFmpeg support libraries.

Code Examples

Loading and playing a video

// Game member variables
Video         m_introVideo;
VideoPlayer   m_videoPlayer;

// LoadContent()
void MyGame::LoadContent() {
    m_introVideo = content.Load<Video>("videos/intro");
    m_videoPlayer.IsLooped = false;
    m_videoPlayer.Volume   = 1.0f;
    m_videoPlayer.Play(m_introVideo);
}

Getting the current frame and drawing with SpriteBatch

// Draw()
void MyGame::Draw(GameTime gameTime) {
    graphicsDevice->Clear(Color::Black);

    Texture2D* frame = m_videoPlayer.GetTexture();
    if (frame != nullptr) {
        spriteBatch->Begin();
        spriteBatch->Draw(
            frame,
            Rectangle(0, 0,
                graphicsDevice->GetViewport().Width,
                graphicsDevice->GetViewport().Height),
            Color::White);
        spriteBatch->End();
    }
}

Checking playback state and looping

// Update()
void MyGame::Update(GameTime gameTime) {
    if (m_videoPlayer.State == MediaState::Stopped) {
        // Intro finished — transition to the main menu
        LoadMainMenu();
        return;
    }

    // Display elapsed / total time
    TimeSpan pos   = m_videoPlayer.PlayPosition;
    TimeSpan total = m_introVideo.Duration;
    UpdateProgressBar(pos, total);
}

// Enable looping before playback begins
m_videoPlayer.IsLooped = true;
m_videoPlayer.Play(m_backgroundVideo);

Pausing and resuming on input

// Update()
void MyGame::Update(GameTime gameTime) {
    auto kb = Keyboard::GetState();

    if (kb.IsKeyDown(Keys::Space) && m_prevKeyboard.IsKeyUp(Keys::Space)) {
        if (m_videoPlayer.State == MediaState::Playing) {
            m_videoPlayer.Pause();
        } else if (m_videoPlayer.State == MediaState::Paused) {
            m_videoPlayer.Resume();
        }
    }

    if (kb.IsKeyDown(Keys::Escape) && m_prevKeyboard.IsKeyUp(Keys::Escape)) {
        m_videoPlayer.Stop();
    }

    m_prevKeyboard = kb;
}