MediaInfo: reading technical metadata from video and audio files

MediaInfo reports technical metadata without modifying or transcoding the files it reads

MediaInfo examines video and audio files and reports technical data including stream counts, codec identifiers, bit rates, frame rates, sample rates, duration, container type, and the tags embedded in each file, without changing any of that content. The tool is a front-end that wraps MediaInfoLib, a separate C++ library that handles the actual format parsing. This repository holds only the front-end code for the CLI and the desktop GUIs; MediaInfoLib is a distinct repository that must be cloned alongside MediaInfo before any build can start.

Two access paths exist: a CLI for scripting or automated batch processing, and a set of GUIs for interactive use. For users who do not need to modify the source, pre-built packages for multiple platforms are distributed at MediaArea.net/MediaInfo. The build instructions in this repository target developers who need to build or modify the code.

MediaInfo does not transcode, repair, or validate files. If a container header claims one codec but wraps another, the output reflects what the parser in MediaInfoLib reads from that header, and discrepancies between what MediaInfo reports and what a player does are outside the scope of this tool.

Four repositories to clone and Visual Studio 2022 as the minimum toolset on Windows

Building MediaInfo on Windows starts with cloning four repositories into the same parent directory: MediaInfo, MediaInfoLib, ZenLib, and zlib. Build scripts assume all four exist as siblings and that development tools are available on `PATH`. If Graph Plugin support is also required, two additional repositories must be cloned alongside the original four: MediaArea-Utils-Binaries and MediaInfo-Graph-Plugin-Binaries.

The minimum toolset is Git for Windows or GitHub Desktop alongside Visual Studio 2022 Community Edition. Visual Studio 2026 is also accepted, but it changes the project files: throughout the build guide, VS 2022 targets `.sln` files in `MSVC2022` directories, while VS 2026 targets `.slnx` files in `MSVC2026` directories, and every MSBuild command in the guide must be adjusted when switching between the two versions.

There is no automated dependency fetching or superbuild for the four-repository setup, which means cloning and environment configuration are manual steps that must complete before any build command is run.

MSBuild for the Windows CLI and an optional PowerShell packaging script

The CLI build on Windows targets the solution file in the `MSVC2022` directory:

MSBuild -t:MediaInfo-CLI -p:Configuration=Release;Platform=x64 MediaInfo\Project\MSVC2022\MediaInfo.sln

For VS 2026, substitute the `MSVC2026` directory and the `.slnx` extension. A PowerShell build script also handles the CLI build and accepts architecture and toolset parameters:

.\MediaInfo\Release\Build_CLI_Windows.ps1 <arch> <msvc>

The `<arch>` parameter accepts Win32, x64 or ARM64; `<msvc>` takes MSVC2022 or MSVC2026. A companion script, `Release_CLI_Windows.ps1`, generates a zip package after the build and requires 7z and Curl from the MediaArea-Utils-Binaries repository.

Windows builds support x86, x86-64/x64/amd64 and ARM64 architectures. The CLI targets various desktop operating systems; Linux and macOS builds have their own dedicated section in the repository.

Qt GUI: DLL build first, Qt 6.11.0 minimum for Windows 11, then qmake and jom

Building the Qt GUI requires more preparation than the CLI. Qt must be installed; the guide recommends the latest version or at least 6.11.0 for Windows 11. Python is also needed to update translation files and can be installed from the Microsoft Store.

Before the Qt GUI build, the MediaInfoLib DLL must be compiled separately:

MSBuild -t:MediaInfoDLL -p:Configuration=Release;Platform=x64 MediaInfoLib\Project\MSVC2022\MediaInfoLib.sln

With the DLL in place, qmake and jom produce the Qt GUI in two commands:

qmake.exe MediaInfo\Project\QMake\GUI\MediaInfoQt.pro -spec win32-msvc "CONFIG+=qtquickcompiler"
jom.exe

Running the application from the command line requires deploying Qt dependencies with windeployqt first, after which `x64\MediaInfo.exe` starts the GUI:

windeployqt --no-quick-import --no-translations --no-system-d3d-compiler --no-system-dxc-compiler --no-compiler-runtime --no-opengl-sw x64\MediaInfo.exe

From Qt Creator, pressing Ctrl + R handles both the deployment and launch without that extra step.

VCL requires C++Builder 12 and two GetIt packages; the README build command is truncated

The VCL GUI runs only on Windows and requires C++Builder 12 Community Edition from Embarcadero. Two packages must be installed from the GetIt Package Manager inside the IDE: VCL Windows Style - Windows11 Dark 1.0 by Embarcadero Technologies, and EdgeView2 SDK 1.0.2739.1 by Microsoft.

The VCL build preparation starts with an MSBuild command that appears in the README as:

MSBuild -t:MediaInfoDLL -p:Configuration=Rel

This command ends there. The equivalent DLL build in the Qt GUI section includes the full configuration name, the platform flag, and the path to `MediaInfoLib\Project\MSVC2022\MediaInfoLib.sln`. The VCL copy omits all of that after the beginning of the configuration flag, which means the README text was cut off before the command was complete. Anyone building the VCL GUI needs to locate a complete version of this command from outside the README.

This truncation is specific to the VCL section. The Qt, UWP, wxWidgets, and CLI build steps are all complete as written.

Qt and wxWidgets run on Linux; UWP and VCL are Windows-only; Android has its own separate GUI

Four GUI variants target Windows: Qt, UWP, VCL, and wxWidgets. Linux supports two of those: Qt and wxWidgets. UWP and VCL have no Linux variants. Android and Apple OS each have separate GUI implementations that are distinct from the desktop GUIs in this repository.

For a developer who needs both a Windows GUI and a Linux GUI, wxWidgets is the one framework that produces builds on both platforms. The option that works across the widest range of operating systems is the CLI.

For macOS, the README index lists a section titled "Build for macOS and Linux" with subsections for platform-specific dependencies and both CLI and GUI build steps. Those steps are not covered in this article. The three CI workflows in the repository are MediaInfo_Checks, MediaInfo-Qt Checks, and MediaInfo-Android Checks, indicating automated testing covers the general build, the Qt variant, and the Android variant.

Year-month build numbers and separate history files for CLI and GUI

The three most recent builds are numbered 26.10, 26.05 and 26.01, corresponding to October 2026, May 2026 and January 2026 respectively. The last push was on 2026-10-06.

Change history is split into two separate files at the repository root: History_CLI.txt and History_GUI.txt. CLI and GUI changes are logged independently, so a developer checking for command-line behavior changes can read History_CLI.txt without reading through GUI rendering updates.

The full license text appears in License.html and LICENSE at the root; the identifier is BSD-2-Clause.

Editorial conclusion

MediaInfo fits projects that need to read technical track data from video and audio files without altering them. Windows users building from source must clone four repositories and have Visual Studio 2022 or 2026, with build tools on `PATH` before running MSBuild. For Linux and macOS, the README contains separate build sections with platform-specific dependency steps that are not reproduced here. The VCL GUI build steps end mid-command in the README, so that variant requires additional documentation before it can be completed. VS 2026 users must substitute `.slnx` files from `MSVC2026` directories in place of `.sln` files from `MSVC2022` throughout each MSBuild step.

Frequently asked questions

Official sources

1. License: BSD-2-Clause
2. MediaArea/MediaInfo on GitHub
3. Project website
4. README
5. Releases