feat: upgrade FFmpeg to 8.0.1 and restore upstream headers

- Update FFmpeg version references to 8.0.1 in builder, fetch, and documentation
- Replace patched `libavformat/avformat.h` with original upstream header (removes manual struct patch)
- Update static library download URL to n8.0.1
- Regenerate Go bindings with improved generator: skip anonymous structs and fields CGO cannot reference
- Add manual Go binding for AVStreamGroupTileGrid offsets in custom.go using a typedef for the anonymous struct
- Apply upstream bugfixes to `libavutil/common.h` macros
- All tests pass and generator logs/documentation updated

Author: flexiondotorg

README.md

@@ -12,15 +12,15 @@ Build once, deploy anywhere. No hunting for system FFmpeg. No version mismatches
 
 ## Features
 
-- **FFmpeg 8.0** - Latest release with AV1, H.265, H.264, VP8/9
+- **FFmpeg 8.0.1** - Latest release with AV1, H.265, H.264, VP8/9
 - **Truly static** - Builds into your binary (just needs system `m` and `stdc++` libraries)
 - **Cross-platform** - Linux and macOS (arm64, amd64)
 - **Hardware acceleration** - NVENC/NVDEC, VideoToolbox, Vulkan and QuickSync support
 - **GPL build** - x264, x265, and all the good codecs included
 - **Auto-generated** - Thin, predictable bindings directly from FFmpeg headers
 - **Preserved documentation** - Original FFmpeg comments in your IDE
 
-*Hard fork of the excellent [csnewman/ffmpeg-go](https://github.com/csnewman/ffmpeg-go), modernised with FFmpeg 8.0, Go 1.24, hardware acceleration and a 99.5% smaller git history.*
+*Hard fork of the excellent [csnewman/ffmpeg-go](https://github.com/csnewman/ffmpeg-go), modernised with FFmpeg 8.0.x, Go 1.24, hardware acceleration, ~85% FFmpeg API coverage, and a 99.5% smaller git history.*
 
 ## Installation
 
@@ -83,7 +83,7 @@ If you need complete FFmpeg with all filters, use the official FFmpeg distributi
 
 | Library          | Version     | Description                                                                        |
 |------------------|-------------|------------------------------------------------------------------------------------|
-| FFmpeg           | 8.0         | A complete, cross-platform solution to record, convert and stream audio and video  |
+| FFmpeg           | 8.0.1       | A complete, cross-platform solution to record, convert and stream audio and video  |
 | dav1d            | 1.5.2       | AV1 cross-platform decoder, open-source, and focused on speed, size and correctness|
 | glslang          | 15.4.0      | Khronos-reference front end for GLSL/ESSL and a SPIR-V generator                   |
 | libsrt           | 1.5.5-rc.0a | A transport protocol for ultra low latency live video and audio streaming          |
@@ -93,17 +93,18 @@ If you need complete FFmpeg with all filters, use the official FFmpeg distributi
 | libxml2          | 2.15.1      | An XML parser and toolkit implemented in C                                         |
 | libiconv         | 1.18        | A character set conversion library (*macOS only*)                                  |
 | mp3lame          | 3.100       | A high quality MPEG Audio Layer III (MP3) encoder                                  |
-| nv-codec-headers | 11.1.5.3    | Headers required to interface with Nvidias codec APIs (*Linux only*)               |
+| nv-codec-headers | 12.2.72.0   | Headers required to interface with Nvidias codec APIs (*Linux only*)               |
 | openssl          | 3.6.0       | Open Source Toolkit for the TLS, DTLS, and QUIC protocols.                         |
 | opus             | 1.5.2       | A totally open, royalty-free, highly versatile audio codec                         |
-| rav1e            | 0.8.2       | The fastest and safest AV1 encoder.                                                |
-| Vulkan-Headers   | 1.4.332     | Vulkan header files and API registry                                               |
-| VVenC            | 1.13.1      | Fraunhofer Versatile Video Encoder, a fast & efficient software H.266/VVC encoder  |
+| rav1e            | 0.8.1       | The fastest and safest AV1 encoder.                                                |
+| Vulkan-Headers   | 1.4.335     | Vulkan header files and API registry                                               |
 | x264             | head        | H.264/MPEG-4 AVC compression format library for encoding video streams             |
 | x265             | head        | H.265/MPEG-H HEVC compression format library for encoding video streams            |
 | zimg             | 3.0.6       | Scaling, colorspace conversion, and dithering library                              |
 | zlib             | 1.3.1       | A Massively Spiffy Yet Delicately Unobtrusive Compression Library                  |
 
+VVenC 1.13.1 (Fraunhofer Versatile Video Encoder, a fast & efficient software H.266/VVC encoder) is in the build configuration, **but currently disabled**, as it adds ~25MB to the static ffmpeg library and is too slow for practical use.
+
 ### Enabled Codecs
 
 Details of codecs, muxers and parsers available in enable in the static ffmpeg library that ffmpeg-statigo ships are documented in [`docs/CODECS.md`](docs/CODECS.md).

custom.go

@@ -16,6 +16,15 @@ extern const AVOutputFormat *av_muxer_iterate(void **opaque);
 extern const AVInputFormat *av_demuxer_iterate(void **opaque);
 extern const AVFilter *av_filter_iterate(void **opaque);
 extern const AVBitStreamFilter *av_bsf_iterate(void **opaque);
+
+// Typedef for anonymous struct inside AVStreamGroupTileGrid.
+// The 'offsets' field is an array of these structs containing tile position info.
+// We create a typedef so CGO can reference it by a stable name.
+typedef struct {
+    unsigned int idx;
+    int horizontal;
+    int vertical;
+} AVStreamGroupTileGridOffset;
 */
 import "C"
 import (
@@ -264,3 +273,94 @@ func AVUuidCopy(dest *AVUUID, src *AVUUID) {
 func AVUuidNil(uu *AVUUID) {
 	C.av_uuid_nil((*C.uint8_t)(unsafe.Pointer(&uu[0])))
 }
+
+// --- Manual binding for anonymous struct in AVStreamGroupTileGrid ---
+
+// AVStreamGroupTileGridOffset wraps the anonymous struct used in AVStreamGroupTileGrid.offsets.
+// This is a tile grid offset structure containing the stream index and pixel offsets.
+type AVStreamGroupTileGridOffset struct {
+	ptr *C.AVStreamGroupTileGridOffset
+}
+
+// RawPtr returns the underlying C pointer.
+func (s *AVStreamGroupTileGridOffset) RawPtr() unsafe.Pointer {
+	return unsafe.Pointer(s.ptr)
+}
+
+// ToAVStreamGroupTileGridOffsetArray creates an Array accessor for a slice of offsets.
+func ToAVStreamGroupTileGridOffsetArray(ptr unsafe.Pointer) *Array[*AVStreamGroupTileGridOffset] {
+	if ptr == nil {
+		return nil
+	}
+
+	return &Array[*AVStreamGroupTileGridOffset]{
+		elemSize: unsafe.Sizeof(C.AVStreamGroupTileGridOffset{}),
+		loadPtr: func(pointer unsafe.Pointer) *AVStreamGroupTileGridOffset {
+			cValue := (*C.AVStreamGroupTileGridOffset)(pointer)
+			return &AVStreamGroupTileGridOffset{ptr: cValue}
+		},
+		ptr: ptr,
+		storePtr: func(pointer unsafe.Pointer, value *AVStreamGroupTileGridOffset) {
+			dest := (*C.AVStreamGroupTileGridOffset)(pointer)
+			if value != nil {
+				*dest = *value.ptr
+			}
+		},
+	}
+}
+
+// Idx gets the idx field.
+// Index of the stream in the group this tile references.
+// Must be < AVStreamGroup.nb_streams.
+func (s *AVStreamGroupTileGridOffset) Idx() uint {
+	return uint(s.ptr.idx)
+}
+
+// SetIdx sets the idx field.
+func (s *AVStreamGroupTileGridOffset) SetIdx(value uint) {
+	s.ptr.idx = (C.uint)(value)
+}
+
+// Horizontal gets the horizontal field.
+// Offset in pixels from the left edge of the canvas where the tile should be placed.
+func (s *AVStreamGroupTileGridOffset) Horizontal() int {
+	return int(s.ptr.horizontal)
+}
+
+// SetHorizontal sets the horizontal field.
+func (s *AVStreamGroupTileGridOffset) SetHorizontal(value int) {
+	s.ptr.horizontal = (C.int)(value)
+}
+
+// Vertical gets the vertical field.
+// Offset in pixels from the top edge of the canvas where the tile should be placed.
+func (s *AVStreamGroupTileGridOffset) Vertical() int {
+	return int(s.ptr.vertical)
+}
+
+// SetVertical sets the vertical field.
+func (s *AVStreamGroupTileGridOffset) SetVertical(value int) {
+	s.ptr.vertical = (C.int)(value)
+}
+
+// Offsets gets the offsets field from AVStreamGroupTileGrid.
+// Returns an array of tile grid offsets containing stream index and pixel positions.
+// The offsets field is an anonymous struct in C, so we cast to our compatible typedef.
+func (s *AVStreamGroupTileGrid) Offsets() *AVStreamGroupTileGridOffset {
+	// The C field is an anonymous struct pointer; cast to our compatible typedef
+	value := unsafe.Pointer(s.ptr.offsets)
+	if value == nil {
+		return nil
+	}
+	return &AVStreamGroupTileGridOffset{ptr: (*C.AVStreamGroupTileGridOffset)(value)}
+}
+
+// SetOffsets sets the offsets field on AVStreamGroupTileGrid.
+func (s *AVStreamGroupTileGrid) SetOffsets(value *AVStreamGroupTileGridOffset) {
+	if value != nil {
+		// Use unsafe pointer to bypass CGO type checking between compatible struct types
+		*(*unsafe.Pointer)(unsafe.Pointer(&s.ptr.offsets)) = unsafe.Pointer(value.ptr)
+	} else {
+		*(*unsafe.Pointer)(unsafe.Pointer(&s.ptr.offsets)) = nil
+	}
+}

docs/DEVELOPMENT.md

@@ -14,8 +14,8 @@ Go modules don't handle 100MB+ binary files. The `go get` command won't fetch st
 
 Projects using ffmpeg-statigo follow this pattern. Reference implementations with justfiles and GitHub workflows:
 
-- [jivedrop](https://github.com/linuxmatters/jivedrop) — *Drop your podcast .wav into a neat MP3, ship the show metadata, cover art, and all 🪩*
-- [jivefire](https://github.com/linuxmatters/jivefire) — *Spin your podcast .wav into a groovy MP4 visualiser. Cava-inspired real-time audio frequencies 🔥*
+- [jivedrop](https://github.com/linuxmatters/jivedrop) — *Drop your podcast .wav into a shiny MP3 with metadata, cover art, and all 🪩*
+- [jivefire](https://github.com/linuxmatters/jivefire) — *Spin your podcast .wav into a groovy MP4 visualiser with Cava-inspired real-time audio frequencies 🔥*
 
 ### Project Structure
 

ffmpeg_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestVersions(t *testing.T) {
-	// FFmpeg 8.0: version 62.3.100 = 0x3E0364 = 4066148
+	// FFmpeg 8.0.x: libavcodec version 62.11.100 (0x3E0B64 = 4066148)
 	assert.Equal(t, 4066148, int(ffmpeg.AVCodecVersion()), "AVCodec version should match expected")
 	assert.Equal(t, ffmpeg.LIBAVCodecVersionInt, int(ffmpeg.AVCodecVersion()), "AVCodec version func and const should match")
 }

include/libavformat/avformat.h

@@ -950,29 +950,6 @@ typedef struct AVStream {
  * sizeof(AVStreamGroupTileGrid) is not a part of the ABI and may only be
  * allocated by avformat_stream_group_create().
  */
-
-/**
- * Tile grid offset structure.
- */
-struct UnnamedStruct_avformat_986_5 {
-    /**
-     * Index of the stream in the group this tile references.
-     *
-     * Must be < @ref AVStreamGroup.nb_streams "nb_streams".
-     */
-    unsigned int idx;
-    /**
-     * Offset in pixels from the left edge of the canvas where the tile
-     * should be placed.
-     */
-    int horizontal;
-    /**
-     * Offset in pixels from the top edge of the canvas where the tile
-     * should be placed.
-     */
-    int vertical;
-};
-
 typedef struct AVStreamGroupTileGrid {
     const AVClass *av_class;
 
@@ -1006,7 +983,24 @@ typedef struct AVStreamGroupTileGrid {
      *
      * Freed by libavformat in avformat_free_context().
      */
-    struct UnnamedStruct_avformat_986_5 *offsets;
+    struct {
+        /**
+         * Index of the stream in the group this tile references.
+         *
+         * Must be < @ref AVStreamGroup.nb_streams "nb_streams".
+         */
+        unsigned int idx;
+        /**
+         * Offset in pixels from the left edge of the canvas where the tile
+         * should be placed.
+         */
+        int horizontal;
+        /**
+         * Offset in pixels from the top edge of the canvas where the tile
+         * should be placed.
+         */
+        int vertical;
+    } *offsets;
 
     /**
      * The pixel value per channel in RGBA format used if no pixel of any tile

include/libavutil/common.h

@@ -486,13 +486,13 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
  * to prevent undefined results.
  */
 #define GET_UTF8(val, GET_BYTE, ERROR)\
-    val= (GET_BYTE);\
+    val= (uint8_t)(GET_BYTE);\
     {\
         uint32_t top = (val & 128) >> 1;\
         if ((val & 0xc0) == 0x80 || val >= 0xFE)\
             {ERROR}\
         while (val & top) {\
-            unsigned int tmp = (GET_BYTE) - 128;\
+            unsigned int tmp = (uint8_t)(GET_BYTE) - 128;\
             if(tmp>>6)\
                 {ERROR}\
             val= (val<<6) + tmp;\
@@ -511,11 +511,11 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
  *                  typically a goto statement.
  */
 #define GET_UTF16(val, GET_16BIT, ERROR)\
-    val = (GET_16BIT);\
+    val = (uint16_t)(GET_16BIT);\
     {\
         unsigned int hi = val - 0xD800;\
         if (hi < 0x800) {\
-            val = (GET_16BIT) - 0xDC00;\
+            val = (uint16_t)(GET_16BIT) - 0xDC00;\
             if (val > 0x3FFU || hi > 0x3FFU)\
                 {ERROR}\
             val += (hi<<10) + 0x10000;\

include/libavutil/ffversion.h

@@ -1,5 +1,5 @@
 /* Automatically generated by version.sh, do not manually edit! */
 #ifndef AVUTIL_FFVERSION_H
 #define AVUTIL_FFVERSION_H
-#define FFMPEG_VERSION "731bbe9"
+#define FFMPEG_VERSION "n8.0.1"
 #endif /* AVUTIL_FFVERSION_H */

internal/builder/libraries.go

@@ -671,7 +671,7 @@ var libsrt = &Library{
 // ffmpeg - FFmpeg multimedia framework
 var ffmpeg = &Library{
 	Name:          "ffmpeg",
-	URL:           "https://github.com/FFmpeg/FFmpeg/archive/refs/tags/n8.0.tar.gz",
+	URL:           "https://github.com/FFmpeg/FFmpeg/archive/refs/tags/n8.0.1.tar.gz",
 	BuildSystem:   &AutoconfBuild{},
 	SkipAutoFlags: true, // FFmpeg uses --extra-cflags and --extra-ldflags instead
 	PostExtract: func(srcPath string) error {

internal/generator/generator.go

@@ -46,6 +46,26 @@ var fieldCTypeOverrides = map[string]map[string]string{
 	},
 }
 
+// skippedStructs contains struct names that should not be generated.
+// These require manual bindings in custom.go, typically because they are
+// anonymous C structs that CGO cannot directly reference by name.
+var skippedStructs = map[string]bool{
+	// Anonymous struct inside AVStreamGroupTileGrid - CGO generates an internal
+	// name like "struct___12" which is unstable across compilations.
+	"UnnamedStruct_avformat_986_5": true,
+}
+
+// skippedFields contains struct.field combinations that should not be generated.
+// These require manual bindings in custom.go, typically because they reference
+// types that CGO cannot directly access (like anonymous structs).
+var skippedFields = map[string]map[string]bool{
+	"AVStreamGroupTileGrid": {
+		// The offsets field is a pointer to an anonymous struct that CGO
+		// assigns an internal name. Manual binding in custom.go handles this.
+		"offsets": true,
+	},
+}
+
 // isOutputParameter checks if a parameter name suggests it's an output parameter
 // isOutputParameter detects function parameters that are output parameters.
 // Priority 2 Enhancement: Recovers ~30 functions with output parameters.
@@ -333,6 +353,12 @@ func (g *Generator) generateStructs() {
 	for _, stName := range i.structOrder {
 		st := i.structs[stName]
 
+		// Skip structs that require manual bindings
+		if skippedStructs[st.Name] {
+			log.Println("Skipping struct", st.Name, "(manual binding in custom.go)")
+			continue
+		}
+
 		log.Println("Generating struct", st.Name)
 		o.Commentf("--- Struct %v ---", st.Name)
 		o.Line()
@@ -464,6 +490,15 @@ func (g *Generator) generateStructs() {
 
 	fieldLoop:
 		for _, field := range st.Fields {
+			// Check if this field should be skipped (manual binding in custom.go)
+			if fields, ok := skippedFields[st.Name]; ok {
+				if fields[field.Name] {
+					o.Commentf("%v skipped (manual binding in custom.go)", field.Name)
+					o.Line()
+					continue fieldLoop
+				}
+			}
+
 			fName := strcase.ToCamel(field.Name)
 
 			cName := field.Name

lib/fetch.go

@@ -20,8 +20,8 @@ import (
 )
 
 // Version is the FFmpeg library version (major.minor.patch)
-// The downloader will find the latest internal release (e.g., lib-8.0.0.3)
-const Version = "8.0.0"
+// The downloader will find the latest internal release (e.g., lib-8.0.1.0)
+const Version = "8.0.1"
 
 // DownloadLibs downloads the FFmpeg static libraries for the current platform
 func DownloadLibs() error {