Category Archives: Blog

GPAC 26.07

We are happy to announce the release of GPAC 26.07.

This release brings maintenance fixes as well as updates to existing features, check the complete changelog below for more details !

As usual, installers are available on gpac.io for most common platforms.

Detailed changelog:

General

  • Clean up of remaining test mode and old arch

MPEG-DASH & HLS

  • Improved support of discontinuities in packager and client
  • Add sfrag tolerance to generate segments with a fixed number of fragments but variable-duration fragments
  • Add dashif.ingest profile for DASH-IF Live Ingest
  • SCTE35 and MPD inband and out-of-band events + HLS (wiki)
  • Improved DASH-L3D and LL-HLS
  • Support for cleanup of timeshift buffer in manifest in multi-period cases

Encryption

  • EVP support in encryption for hardware AES
  • AV1 scalable ID (temporal a/o spatial) filtering

Filters

  • Discontinuity detection in reframer and in dasher
  • Improve mediaserver MABR repair option
  • SourceID matching by prefix now possible
  • Add option to switch Periods when new encryption key is encountered
  • Allow DREF URL override in mp4dmx
  • Raw IAMF mux to/demux from MP4
  • Accept empty initial playlist in flist
  • Allow source loading to use custom source filters other than JS
  • Improved GHI demuxer for manifest regeneration
  • Allow ffavf to be used as source
  • Added tolerance for sfrag mode in mp4mx to align to sap frames

Other

  • Added MP4Box option for automatic track reordering
  • Test modes for GF_Blob and gfio from mem in gpac cli
  • Remote monitoring web app now supports inspecting from logs (use -rmt -rmt-log to start recording)
  • Added light formatting syntax to filter status
  • Switch to QJS 26-06
  • Refined gfio from mem to allow multiple concurrent users, needed by some demuxers
  • More configuration options for H2 and H3, improved QUIC support
  • Many bug fixes and security patches

Installers are available here at gpac.io

Enjoy, give us feedback and spread the news!

GPAC 26.02

We are happy to announce the release of GPAC 26.02, moving to year.month naming scheme from now on.

This release brings many new features in packaging, Multicast ABR with HTTP repair, HTTP/3 support and other goodies, check the complete changelog below for more details !

This release also brings a new web UI for remote monitoring of long-running GPAC sessions, allowing real-time visualization of the session.

As usual, installers are available on gpac.io for most common platforms.

Enjoy, give us feedback and spread the news!

Read more: GPAC 26.02

Detailed changelog:

gpac

  • Added mode for testing deferred graph linking apps
  • main() can return filter session error code using -rv

MP4Box

  • Better support for HEIF/AVIF import
  • New ‘times’ option to rewrite timestamps

Core tools

  • Network Capture and Replay using pcap or pcapng, including looping, loss and reordering simulation
  • HTTP/3 support for client and server
  • Added libcurl as backend for GPAC downloader
  • QuickJS 2025, FFmpeg 8
  • Improved GFIO (including file deletion)

Media Formats

  • ISOBMFF external tracks support
  • Event Message Tracks support
  • Improved support SCTE-35, id3, CC, timecodes and other markers
  • Improved HDR signaling support
  • IAMF support
  • Motion JPEG2000
  • AC-4 support
  • AVS3 support

MPEG-DASH & HLS

  • SSR support for L3D low latency, base64 encoding of init segments
  • HLS groups, IV injection
  • DASH/HLS: new segcts option to derive startNumber from first packet cts
  • mux time prft injection

Remote monitoring

  • A new WebSocket based remote monitoring UI is available for GPAC
  • WebSocket server for JS scripts

Filters

  • DVB-I MABR FLUTE mux and demux
  • MABR (ROUTE/FLUTE) HTTP repair support with full or partial modes
  • MABR (ROUTE/FLUTE) on unicast
  • mediaserver.js HTTP gateway filter supporting MABR sources
  • avmix playlists now accept ipid:// urls to locate input pids, allowing to specify playlists independently from source URLs
  • ClosedCaptions encoder
  • TTML merger
  • flist: Playlist piping, DASH perdiod auto-switch signaling
  • pin: flush signaling upon broken pipe
  • M2TS: USAC support, non real-time NTP injection for TEMI, real-time regulation option for tssplit and tsgendts
  • dvb4linux is back (Terrestrial and Satelite including dibseqc)
  • reframer: time-aligned mode, time discontinuities handling
  • nhml: ability to process fragmented streams
  • bsrw: timecodes injection and rewriting
  • seiloader filter for SEI and AV1 OBUs
  • FFmpeg raw protocol support (use gpac for demux and mux)

Emscripten

  • Improved WASM support
  • Fixes in UI

Other

  • Improved Wiki: glossary, developer section, …
  • Integration with GStreamer (gpac-gst-plugin)
  • Introduce unit tests in complement to the testsuite and various buildbot continuous checks
  • Many bug fixes and security patches

Announcing MP4Box.js 1.0.0 with TypeScript support

MP4Box.js – GPAC’s first venture into JavaScript inspired by the MP4Box tool – makes it easy to parse, segment, and manipulate MP4 files in browsers or Node.js.

Over time it’s become an unavoidable tool for Javascript developers willing to analyze, manipulate or generate media content in the browser or any Javascript runtime.

Since version 0.5.2 (Mar 2022), the library has undergone significant evolution: the codebase was modernized, new capabilities were added, and support for additional MP4 box types and streaming formats was extended. Below Deniz Uğur and I highlight the most important changes (released officially in v0.5.3/v0.5.4 and v0.6.x up through v1.0.0), focusing on new features, interface enhancements, and architectural improvements.

Refactored Codebase and TypeScript Support

A key milestone came in version 0.6.0, which is a complete refactor to modern JavaScript. The library was converted into an ECMAScript Module and rewritten in TypeScript.

In practice this means MP4Box.js now ships as an ES module (with CJS compatibility) and includes TypeScript type definitions out-of-the-box. Developers can import MP4Box.js with modern import syntax and enjoy full typing support. This modernization also brought an updated build toolchain (e.g. bundler and linting) and makes integration into contemporary web apps and Node environments much smoother.

The migration is largely transparent to existing code.

Expanded Compatibility for Box Types and MPEG Conformance Streams

Alongside the architectural rewrite, several updates improved compatibility with new MP4 box types and streaming scenarios:

  • MPEG ISOBMFF Box Support – So much to write here, that led us to be up-to-date with MPEG’s ISOBMFF specification. For example, a fix was added to recognize version 1 of the cslg (composition to decode timeline) box, which is used by certain tools like GStreamer. Previously MP4Box.js ignored this newer box version, but now it can parse it correctly. MP4Box.js 1.0.0 enhances compatibility with files produced by modern encoders.
  • Stream Type Extensions (v0.6.4) – The parsing interface was extended to accept additional stream types. In other words, MP4Box.js now recognizes more container streams when you call its parse methods. This lets developers feed in different kinds of input (e.g. alternative fetch or file streams) without having to patch the library.
  • ArrayBuffer fileStart Parameter (v0.6.4) – MP4Box.js’ extended ArrayBuffer type (MP4BoxBuffer.fromArrayBuffer) was updated to require fileStart property explicitlyThis allows you to append ArrayBuffer segments at a specific offset in the virtual file. In practice, this makes progressive loading more flexible (for example, appending fragments of a large MP4 file in order), and it aligns MP4Box.js’s streaming API more closely with the original MP4Box (CLI) behavior.

Enhanced File Saving and mdat Handling

Versions leading up to 1.0.0 introduced more powerful file output capabilities, particularly around the media data (mdat):

  • Rewriting Entire MP4 (v1.0.0) – A big portion of the effort went into fixing issues around MP4Box.js that was preventing valid rewriting of the file including the mdat box. In earlier versions, saving an MP4 often omitted the large media payload (mdat), resulting in an output with only headers. Now MP4Box.js can generate a complete MP4 file (with both metadata and media data) in one step. This is useful for workflows that manipulate or concatenate full MP4 files on the client side.
  • Breaking Change: discardMdatData Default (v1.0.0) – To manage memory use, version 1.0.0 changed the default behavior so that discardMdatData is now true by default. This means by default MP4Box.js will discard (not store) the raw media data it parses unless you explicitly disable this flag. If your application needs the media bytes for rewriting, you can create the file with createFile(true)before parsing. Be aware of this change if upgrading, as it was not the previous default behavior.

More Comprehensive Testing

MPEG Group has built a File Format Conformance Framework around 2 years ago that made it easier to access conformance files. Our contributor Deniz Uğur took advantage of this and tested MP4Box.js against the conformance files from there.

  • Structural Tests – Our testsuite ensures the parsed box layout is identical to what GPAC can output and what was reviewed and accepted by the MPEG File Format group.
  • Roundtrip Tests – We also make sure we can read a file, write it, and read it again without any discrepancies.

Other Interface Improvements and Fixes

Beyond the headline changes above, MP4Box.js received numerous smaller but impactful tweaks:

  • Bug Fixes and Registry Improvements (v0.6.4) – Various internal fixes were made to the box-type registry and parsing logic. For example, box definitions were cleaned up to separate different internal cases, and validation was tightened. While these are mostly behind-the-scenes, they improve stability when dealing with edge-case MP4 files.
  • Streamlining and Cleanup – In multiple releases (v0.6.2, v0.6.3, etc.) general fixes were applied across the codebase (e.g. dependency fixes, housekeeping, and compliance updates). These don’t add new user-facing features, but they ensure the library is more maintainable and compliant with future standards (for instance, fixing build scripts and updating dependencies).

Overall, since v0.5.2 the MP4Box.js library has matured significantly. It now leverages modern JavaScript practices (ESM + TypeScript), has better support for varied MP4 formats and streaming scenarios, and can fully rewrite MP4 files with their media data. These enhancements make MP4Box.js a more powerful and flexible tool for web developers working with GPAC.Last but not least: many thanks to the community and our contributors. Long live MP4Box.js!

100 Million Downloads: A Milestone for the GPAC Community

Looking back on 25 years of code, collaboration, and quiet, but massive impact.

Illustration by Lluc Pallejà of squeakycarrot.com

As GPAC approaches 100 million downloads across its ecosystem of tools, we’d like to take a moment to reflect – and thank the people who made it possible: our users, contributors, testers, and long-time supporters.

From the early academic days at Télécom Paris to the growing set of tools used in research, prototyping, packaging, streaming, and browser-based applications, GPAC has always had one core mission: to give developers high-quality, efficient, and modular building blocks for multimedia workflows.

What’s in the 100 Million?

The number includes cumulative downloads across:

  • The core GPAC framework
  • MP4Box, our popular MP4 multiplexer/demultiplexer
  • MP4Box.js, used in browser environments
  • Other associated GPAC tools and libraries available via GitHub, npm, and other repositories

We know download numbers don’t tell the whole story. Open-source software is widely reused, embedded, and adapted – sometimes anonymously. But when a project like GPAC crosses a milestone like this, it’s a signal of sustained interest, real-world use, and global relevance.

🌍 Where GPAC Shows Up

While we don’t always know who our users are, we’ve seen GPAC show up in:

  • Academic research papers, standardization contributions and student projects
  • Streaming architecture experiments
  • Streaming media workflows as used by Netflix with the help of Motion Spell
  • Browser-based applications using MP4Box.js
  • Open-source media toolkits and larger software stacks

We welcome this diversity. It keeps the project grounded, evolving, and truly open.

The upcoming GPAC release will include new features and refinements based on feedback from our contributors and community – especially in areas like:

  • CMAF packaging
  • Pro workflows in DRM and Advertising
  • Enhanced GPAC Filters documentation
  • Browser-based video handling with MP4Box.js

We’ll also continue efforts to make our tools easier to adopt, whether you’re building for experimentation or integrating GPAC into production environments.

Whether you downloaded GPAC once, use it daily, or contributed code, tests, bug reports, or documentation – thank you.

If you’re using GPAC in your work, we’d love to hear about it. You can drop us a note, contribute to the GitHub discussion, or just share a link. Your stories help shape the future of the project.

Here’s to the next 100 million – and to keeping GPAC useful, efficient, and open.

The GPAC team

The Security Landscape of the GPAC Open-Source Project: A Balanced Perspective

GPAC is an open-source multimedia framework used by many developers and organizations to manipulate, package, and stream multimedia content. Given the popularity of GPAC in media manipulation tasks, it has naturally caught the attention of security researchers and organizations such as the Cybersecurity and Infrastructure Security Agency (CISA). Over time, many bugs were discovered, a few vulnerabilities have been flagged, prompting some concern in the development community. However, these reports, especially the recent CISA GPAC advisories, are either outdated or have been adequately addressed by the GPAC team, rendering the issues largely non-serious today.

Understanding GPAC Vulnerabilities

Like any large software project written in C, dealing with bitstream parsing, and started at a time where security was not a concern, GPAC’s codebase has been exposed to many types of crashes and vulnerabilities when fed with wrong input data. The most recent CISA GPAC advisories on GPAC vulnerabilities, while helpful for raising awareness, highlight problems that are no longer pressing.

For example, certain vulnerabilities that surfaced in 2024, which included concerns around memory safety, buffer overflows, and input validation, have already been patched in newer releases.

While CISA’s advisories motivated the GPAC team to address these issues more quickly, it is crucial to understand that CISA GPAC reports have a delayed effect when disseminated to the public, meaning the issues are often resolved by the time the advisories are released.

Most of the vulnerabilities cited by CISA are also categorized as low to medium severity, meaning they do not pose immediate or significant risks for most users. Moreover, they primarily affect environments where the code is not sandboxed properly or where media files are processed directly from untrusted sources—scenarios that can often be mitigated with basic security best practices. Even so, beside causing a potential crash, the path to exploitation remains unclear, making most of these reports more of simple bugs than actual security vulnerabilities.

In addition GPAC has a security policy in place. We invite security researchers to follow the instructions for a swift analysis and resolution of their concerns.

Why The Recent CISA Issues Are Not Serious

A few key reasons illustrate why the CISA-reported GPAC issues are not a current concern:

  1. Timely Patching by the GPAC Team: GPAC’s developer community is highly active, with frequent updates and patches released. The vulnerabilities that CISA flagged have, in many cases, been swiftly addressed by GPAC developers. For example, buffer overflow issues raised in early 2023 were quickly resolved in subsequent software patches. The project’s maintainers work closely with the security community and enroll to the public fuzzing and analysis infrastructures to ensure that these issues are catched and mitigated before they are reported.
  2. Limited Exploitability: The majority of the flagged vulnerabilities require specific, often unrealistic conditions to be exploited. Many of the issues only become relevant when processing malicious media files in very particular environments. For developers who follow standard practices—such as sandboxing, using trusted input sources, and staying updated with the latest patches—the risk remains minimal.
  3. Open-Source Advantages: Being an open-source project, GPAC benefits from having many eyes on its codebase. Vulnerabilities are discovered faster, and the community of developers often provides fixes before any serious exploitation can occur. Additionally, transparency is a cornerstone of GPAC, allowing users to inspect the changes and patches themselves, contributing to a sense of shared responsibility and trust.

Practical Steps for Developers Using GPAC

While GPAC’s security situation is stable, it’s always wise to follow a few best practices when using open-source software:

  • Regularly Updated: Ensure you’re using the latest version of GPAC. The project is regularly maintained, and updates contain security fixes.
  • Sandbox Media Processing: When processing media files, especially from unknown or untrusted sources, use sandboxing to limit the impact of any potential vulnerabilities.
  • Monitor Vulnerability Feeds: Keep an eye on any new GPAC vulnerabilities of your deplyed version by keeping an eye on vulnerability databases like the National Vulnerability Database (NVD) to stay informed about any emerging issues that might affect you.
  • Harden Your Systems: Apply general hardening practices to your systems and environments that use GPAC, such as enabling ASLR (Address Space Layout Randomization), DEP (Data Execution Prevention), and other standard security mechanisms.

Conclusion

The security issues surrounding GPAC, flagged by CISA and other agencies, have been managed with care by the open-source community. Most of the vulnerabilities were low to medium severity, and the project’s maintainers have been proactive in detecting and addressing them using a state-of-the-art security policy.

For developers and organizations using GPAC, following basic security practices—such as updating regularly and using sandboxing—ensures a safe and secure experience. The concerns raised by CISA’s GPAC advisories, while relevant at the time, have become outdated in the current context.

GPAC remains a robust and secure tool for multimedia processing and streaming, with a community that prioritizes both functionality and security.