using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using FFmpeg.AutoGen.Native;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Rationale One")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © Ruslan Balanukhin 2025 All rights reserved.")]
[assembly: AssemblyDescription("FFmpeg auto generated unsafe bindings for C#/.NET and Mono.")]
[assembly: AssemblyFileVersion("8.0.0.1")]
[assembly: AssemblyInformationalVersion("8.0.0.1+8003b88e6a3189bcceba6825e134ad7ed0e06928")]
[assembly: AssemblyProduct("FFmpeg.AutoGen")]
[assembly: AssemblyTitle("FFmpeg.AutoGen")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("8.0.0.1")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FFmpeg.AutoGen
{
	public class ConstCharPtrMarshaler : ICustomMarshaler
	{
		private static readonly ConstCharPtrMarshaler Instance = new ConstCharPtrMarshaler();

		public object MarshalNativeToManaged(IntPtr pNativeData)
		{
			return Marshal.PtrToStringAnsi(pNativeData);
		}

		public IntPtr MarshalManagedToNative(object managedObj)
		{
			return IntPtr.Zero;
		}

		public void CleanUpNativeData(IntPtr pNativeData)
		{
		}

		public void CleanUpManagedData(object managedObj)
		{
		}

		public int GetNativeDataSize()
		{
			return IntPtr.Size;
		}

		public static ICustomMarshaler GetInstance(string cookie)
		{
			return Instance;
		}
	}
	public static class ffmpeg
	{
		public static readonly int EAGAIN;

		public static readonly int ENOMEM;

		public static readonly int EINVAL;

		public static readonly int EPIPE;

		public static Dictionary<string, int> LibraryVersionMap;

		public const int _WIN32_WINNT = 1538;

		public const int AV_BUFFER_FLAG_READONLY = 1;

		public const int AV_BUFFERSINK_FLAG_NO_REQUEST = 2;

		public const int AV_BUFFERSINK_FLAG_PEEK = 1;

		public static readonly ulong AV_CH_BACK_CENTER;

		public static readonly ulong AV_CH_BACK_LEFT;

		public static readonly ulong AV_CH_BACK_RIGHT;

		public static readonly ulong AV_CH_BINAURAL_LEFT;

		public static readonly ulong AV_CH_BINAURAL_RIGHT;

		public static readonly ulong AV_CH_BOTTOM_FRONT_CENTER;

		public static readonly ulong AV_CH_BOTTOM_FRONT_LEFT;

		public static readonly ulong AV_CH_BOTTOM_FRONT_RIGHT;

		public static readonly ulong AV_CH_FRONT_CENTER;

		public static readonly ulong AV_CH_FRONT_LEFT;

		public static readonly ulong AV_CH_FRONT_LEFT_OF_CENTER;

		public static readonly ulong AV_CH_FRONT_RIGHT;

		public static readonly ulong AV_CH_FRONT_RIGHT_OF_CENTER;

		public static readonly ulong AV_CH_LAYOUT_2_1;

		public static readonly ulong AV_CH_LAYOUT_2_2;

		public static readonly ulong AV_CH_LAYOUT_22POINT2;

		public static readonly ulong AV_CH_LAYOUT_2POINT1;

		public static readonly ulong AV_CH_LAYOUT_3POINT1;

		public static readonly ulong AV_CH_LAYOUT_3POINT1POINT2;

		public static readonly ulong AV_CH_LAYOUT_4POINT0;

		public static readonly ulong AV_CH_LAYOUT_4POINT1;

		public static readonly ulong AV_CH_LAYOUT_5POINT0;

		public static readonly ulong AV_CH_LAYOUT_5POINT0_BACK;

		public static readonly ulong AV_CH_LAYOUT_5POINT1;

		public static readonly ulong AV_CH_LAYOUT_5POINT1_BACK;

		public static readonly ulong AV_CH_LAYOUT_5POINT1POINT2;

		public static readonly ulong AV_CH_LAYOUT_5POINT1POINT2_BACK;

		public static readonly ulong AV_CH_LAYOUT_5POINT1POINT4_BACK;

		public static readonly ulong AV_CH_LAYOUT_6POINT0;

		public static readonly ulong AV_CH_LAYOUT_6POINT0_FRONT;

		public static readonly ulong AV_CH_LAYOUT_6POINT1;

		public static readonly ulong AV_CH_LAYOUT_6POINT1_BACK;

		public static readonly ulong AV_CH_LAYOUT_6POINT1_FRONT;

		public static readonly ulong AV_CH_LAYOUT_7POINT0;

		public static readonly ulong AV_CH_LAYOUT_7POINT0_FRONT;

		public static readonly ulong AV_CH_LAYOUT_7POINT1;

		public static readonly ulong AV_CH_LAYOUT_7POINT1_TOP_BACK;

		public static readonly ulong AV_CH_LAYOUT_7POINT1_WIDE;

		public static readonly ulong AV_CH_LAYOUT_7POINT1_WIDE_BACK;

		public static readonly ulong AV_CH_LAYOUT_7POINT1POINT2;

		public static readonly ulong AV_CH_LAYOUT_7POINT1POINT4_BACK;

		public static readonly ulong AV_CH_LAYOUT_7POINT2POINT3;

		public static readonly ulong AV_CH_LAYOUT_9POINT1POINT4_BACK;

		public static readonly ulong AV_CH_LAYOUT_9POINT1POINT6;

		public static readonly ulong AV_CH_LAYOUT_BINAURAL;

		public static readonly ulong AV_CH_LAYOUT_CUBE;

		public static readonly ulong AV_CH_LAYOUT_HEXADECAGONAL;

		public static readonly ulong AV_CH_LAYOUT_HEXAGONAL;

		public static readonly ulong AV_CH_LAYOUT_MONO;

		public static readonly ulong AV_CH_LAYOUT_OCTAGONAL;

		public static readonly ulong AV_CH_LAYOUT_QUAD;

		public static readonly ulong AV_CH_LAYOUT_STEREO;

		public static readonly ulong AV_CH_LAYOUT_STEREO_DOWNMIX;

		public static readonly ulong AV_CH_LAYOUT_SURROUND;

		public static readonly ulong AV_CH_LOW_FREQUENCY;

		public static readonly ulong AV_CH_LOW_FREQUENCY_2;

		public static readonly ulong AV_CH_SIDE_LEFT;

		public static readonly ulong AV_CH_SIDE_RIGHT;

		public static readonly ulong AV_CH_SIDE_SURROUND_LEFT;

		public static readonly ulong AV_CH_SIDE_SURROUND_RIGHT;

		public static readonly ulong AV_CH_STEREO_LEFT;

		public static readonly ulong AV_CH_STEREO_RIGHT;

		public static readonly ulong AV_CH_SURROUND_DIRECT_LEFT;

		public static readonly ulong AV_CH_SURROUND_DIRECT_RIGHT;

		public static readonly ulong AV_CH_TOP_BACK_CENTER;

		public static readonly ulong AV_CH_TOP_BACK_LEFT;

		public static readonly ulong AV_CH_TOP_BACK_RIGHT;

		public static readonly ulong AV_CH_TOP_CENTER;

		public static readonly ulong AV_CH_TOP_FRONT_CENTER;

		public static readonly ulong AV_CH_TOP_FRONT_LEFT;

		public static readonly ulong AV_CH_TOP_FRONT_RIGHT;

		public static readonly ulong AV_CH_TOP_SIDE_LEFT;

		public static readonly ulong AV_CH_TOP_SIDE_RIGHT;

		public static readonly ulong AV_CH_TOP_SURROUND_LEFT;

		public static readonly ulong AV_CH_TOP_SURROUND_RIGHT;

		public static readonly ulong AV_CH_WIDE_LEFT;

		public static readonly ulong AV_CH_WIDE_RIGHT;

		public const int AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL = 2;

		public const int AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS = 1;

		public const int AV_CODEC_CAP_AVOID_PROBING = 131072;

		public const int AV_CODEC_CAP_CHANNEL_CONF = 1024;

		public const int AV_CODEC_CAP_DELAY = 32;

		public const int AV_CODEC_CAP_DR1 = 2;

		public const int AV_CODEC_CAP_DRAW_HORIZ_BAND = 1;

		public const int AV_CODEC_CAP_ENCODER_FLUSH = 2097152;

		public const int AV_CODEC_CAP_ENCODER_RECON_FRAME = 4194304;

		public const int AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE = 1048576;

		public const int AV_CODEC_CAP_EXPERIMENTAL = 512;

		public const int AV_CODEC_CAP_FRAME_THREADS = 4096;

		public const int AV_CODEC_CAP_HARDWARE = 262144;

		public const int AV_CODEC_CAP_HYBRID = 524288;

		public const int AV_CODEC_CAP_OTHER_THREADS = 32768;

		public const int AV_CODEC_CAP_PARAM_CHANGE = 16384;

		public const int AV_CODEC_CAP_SLICE_THREADS = 8192;

		public const int AV_CODEC_CAP_SMALL_LAST_FRAME = 64;

		public const int AV_CODEC_CAP_VARIABLE_FRAME_SIZE = 65536;

		public const int AV_CODEC_EXPORT_DATA_ENHANCEMENTS = 16;

		public const int AV_CODEC_EXPORT_DATA_FILM_GRAIN = 8;

		public const int AV_CODEC_EXPORT_DATA_MVS = 1;

		public const int AV_CODEC_EXPORT_DATA_PRFT = 2;

		public const int AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS = 4;

		public const int AV_CODEC_FLAG_4MV = 4;

		public const int AV_CODEC_FLAG_AC_PRED = 16777216;

		public const int AV_CODEC_FLAG_BITEXACT = 8388608;

		public const uint AV_CODEC_FLAG_CLOSED_GOP = 2147483648u;

		public const int AV_CODEC_FLAG_COPY_OPAQUE = 128;

		public const int AV_CODEC_FLAG_FRAME_DURATION = 256;

		public const int AV_CODEC_FLAG_GLOBAL_HEADER = 4194304;

		public const int AV_CODEC_FLAG_GRAY = 8192;

		public const int AV_CODEC_FLAG_INTERLACED_DCT = 262144;

		public const int AV_CODEC_FLAG_INTERLACED_ME = 536870912;

		public const int AV_CODEC_FLAG_LOOP_FILTER = 2048;

		public const int AV_CODEC_FLAG_LOW_DELAY = 524288;

		public const int AV_CODEC_FLAG_OUTPUT_CORRUPT = 8;

		public const int AV_CODEC_FLAG_PASS1 = 512;

		public const int AV_CODEC_FLAG_PASS2 = 1024;

		public const int AV_CODEC_FLAG_PSNR = 32768;

		public const int AV_CODEC_FLAG_QPEL = 16;

		public const int AV_CODEC_FLAG_QSCALE = 2;

		public const int AV_CODEC_FLAG_RECON_FRAME = 64;

		public const int AV_CODEC_FLAG_UNALIGNED = 1;

		public const int AV_CODEC_FLAG2_CHUNKS = 32768;

		public const int AV_CODEC_FLAG2_EXPORT_MVS = 268435456;

		public const int AV_CODEC_FLAG2_FAST = 1;

		public const uint AV_CODEC_FLAG2_ICC_PROFILES = 2147483648u;

		public const int AV_CODEC_FLAG2_IGNORE_CROP = 65536;

		public const int AV_CODEC_FLAG2_LOCAL_HEADER = 8;

		public const int AV_CODEC_FLAG2_NO_OUTPUT = 4;

		public const int AV_CODEC_FLAG2_RO_FLUSH_NOOP = 1073741824;

		public const int AV_CODEC_FLAG2_SHOW_ALL = 4194304;

		public const int AV_CODEC_FLAG2_SKIP_MANUAL = 536870912;

		public static readonly int AV_CODEC_ID_H265;

		public static readonly int AV_CODEC_ID_H266;

		public static readonly int AV_CODEC_ID_IFF_BYTERUN1;

		public const int AV_CODEC_PROP_BITMAP_SUB = 65536;

		public const int AV_CODEC_PROP_FIELDS = 16;

		public const int AV_CODEC_PROP_INTRA_ONLY = 1;

		public const int AV_CODEC_PROP_LOSSLESS = 4;

		public const int AV_CODEC_PROP_LOSSY = 2;

		public const int AV_CODEC_PROP_REORDER = 8;

		public const int AV_CODEC_PROP_TEXT_SUB = 131072;

		public const int AV_CPU_FLAG_3DNOW = 4;

		public const int AV_CPU_FLAG_3DNOWEXT = 32;

		public const int AV_CPU_FLAG_AESNI = 524288;

		public const int AV_CPU_FLAG_ALTIVEC = 1;

		public const int AV_CPU_FLAG_ARMV5TE = 1;

		public const int AV_CPU_FLAG_ARMV6 = 2;

		public const int AV_CPU_FLAG_ARMV6T2 = 4;

		public const int AV_CPU_FLAG_ARMV8 = 64;

		public const int AV_CPU_FLAG_ATOM = 268435456;

		public const int AV_CPU_FLAG_AVX = 16384;

		public const int AV_CPU_FLAG_AVX2 = 32768;

		public const int AV_CPU_FLAG_AVX512 = 1048576;

		public const int AV_CPU_FLAG_AVX512ICL = 2097152;

		public const int AV_CPU_FLAG_AVXSLOW = 134217728;

		public const int AV_CPU_FLAG_BMI1 = 131072;

		public const int AV_CPU_FLAG_BMI2 = 262144;

		public const int AV_CPU_FLAG_CMOV = 4096;

		public const int AV_CPU_FLAG_DOTPROD = 256;

		public const int AV_CPU_FLAG_FMA3 = 65536;

		public const int AV_CPU_FLAG_FMA4 = 2048;

		public const uint AV_CPU_FLAG_FORCE = 2147483648u;

		public const int AV_CPU_FLAG_I8MM = 512;

		public const int AV_CPU_FLAG_LASX = 2;

		public const int AV_CPU_FLAG_LSX = 1;

		public const int AV_CPU_FLAG_MMI = 1;

		public const int AV_CPU_FLAG_MMX = 1;

		public const int AV_CPU_FLAG_MMX2 = 2;

		public const int AV_CPU_FLAG_MMXEXT = 2;

		public const int AV_CPU_FLAG_MSA = 2;

		public const int AV_CPU_FLAG_NEON = 32;

		public const int AV_CPU_FLAG_POWER8 = 4;

		public const int AV_CPU_FLAG_RV_MISALIGNED = 1024;

		public const int AV_CPU_FLAG_RV_ZVBB = 512;

		public const int AV_CPU_FLAG_RVB = 2048;

		public const int AV_CPU_FLAG_RVB_ADDR = 256;

		public const int AV_CPU_FLAG_RVB_BASIC = 128;

		public const int AV_CPU_FLAG_RVD = 4;

		public const int AV_CPU_FLAG_RVF = 2;

		public const int AV_CPU_FLAG_RVI = 1;

		public const int AV_CPU_FLAG_RVV_F32 = 16;

		public const int AV_CPU_FLAG_RVV_F64 = 64;

		public const int AV_CPU_FLAG_RVV_I32 = 8;

		public const int AV_CPU_FLAG_RVV_I64 = 32;

		public const int AV_CPU_FLAG_SETEND = 65536;

		public const int AV_CPU_FLAG_SIMD128 = 1;

		public const int AV_CPU_FLAG_SLOW_GATHER = 33554432;

		public const int AV_CPU_FLAG_SSE = 8;

		public const int AV_CPU_FLAG_SSE2 = 16;

		public const int AV_CPU_FLAG_SSE2SLOW = 1073741824;

		public const int AV_CPU_FLAG_SSE3 = 64;

		public const int AV_CPU_FLAG_SSE3SLOW = 536870912;

		public const int AV_CPU_FLAG_SSE4 = 256;

		public const int AV_CPU_FLAG_SSE42 = 512;

		public const int AV_CPU_FLAG_SSSE3 = 128;

		public const int AV_CPU_FLAG_SSSE3SLOW = 67108864;

		public const int AV_CPU_FLAG_SVE = 1024;

		public const int AV_CPU_FLAG_SVE2 = 2048;

		public const int AV_CPU_FLAG_VFP = 8;

		public const int AV_CPU_FLAG_VFP_VM = 128;

		public const int AV_CPU_FLAG_VFPV3 = 16;

		public const int AV_CPU_FLAG_VSX = 2;

		public const int AV_CPU_FLAG_XOP = 1024;

		public const int AV_DICT_APPEND = 32;

		public const int AV_DICT_DEDUP = 128;

		public const int AV_DICT_DONT_OVERWRITE = 16;

		public const int AV_DICT_DONT_STRDUP_KEY = 4;

		public const int AV_DICT_DONT_STRDUP_VAL = 8;

		public const int AV_DICT_IGNORE_SUFFIX = 2;

		public const int AV_DICT_MATCH_CASE = 1;

		public const int AV_DICT_MULTIKEY = 64;

		public const int AV_DISPOSITION_ATTACHED_PIC = 1024;

		public const int AV_DISPOSITION_CAPTIONS = 65536;

		public const int AV_DISPOSITION_CLEAN_EFFECTS = 512;

		public const int AV_DISPOSITION_COMMENT = 8;

		public const int AV_DISPOSITION_DEFAULT = 1;

		public const int AV_DISPOSITION_DEPENDENT = 524288;

		public const int AV_DISPOSITION_DESCRIPTIONS = 131072;

		public const int AV_DISPOSITION_DUB = 2;

		public const int AV_DISPOSITION_FORCED = 64;

		public const int AV_DISPOSITION_HEARING_IMPAIRED = 128;

		public const int AV_DISPOSITION_KARAOKE = 32;

		public const int AV_DISPOSITION_LYRICS = 16;

		public const int AV_DISPOSITION_METADATA = 262144;

		public const int AV_DISPOSITION_MULTILAYER = 2097152;

		public const int AV_DISPOSITION_NON_DIEGETIC = 4096;

		public const int AV_DISPOSITION_ORIGINAL = 4;

		public const int AV_DISPOSITION_STILL_IMAGE = 1048576;

		public const int AV_DISPOSITION_TIMED_THUMBNAILS = 2048;

		public const int AV_DISPOSITION_VISUAL_IMPAIRED = 256;

		public const int AV_EF_AGGRESSIVE = 262144;

		public const int AV_EF_BITSTREAM = 2;

		public const int AV_EF_BUFFER = 4;

		public const int AV_EF_CAREFUL = 65536;

		public const int AV_EF_COMPLIANT = 131072;

		public const int AV_EF_CRCCHECK = 1;

		public const int AV_EF_EXPLODE = 8;

		public const int AV_EF_IGNORE_ERR = 32768;

		public const int AV_ERROR_MAX_STRING_SIZE = 64;

		public const int AV_FOURCC_MAX_STRING_SIZE = 32;

		public const int AV_FRAME_FILENAME_FLAGS_MULTIPLE = 1;

		public const int AV_FRAME_FLAG_CORRUPT = 1;

		public const int AV_FRAME_FLAG_DISCARD = 4;

		public const int AV_FRAME_FLAG_INTERLACED = 8;

		public const int AV_FRAME_FLAG_KEY = 2;

		public const int AV_FRAME_FLAG_LOSSLESS = 32;

		public const int AV_FRAME_FLAG_TOP_FIELD_FIRST = 16;

		public const int AV_FRAME_SIDE_DATA_FLAG_NEW_REF = 4;

		public const int AV_FRAME_SIDE_DATA_FLAG_REPLACE = 2;

		public const int AV_FRAME_SIDE_DATA_FLAG_UNIQUE = 1;

		public const int AV_GET_BUFFER_FLAG_REF = 1;

		public const int AV_GET_ENCODE_BUFFER_FLAG_REF = 1;

		public const int AV_HAVE_BIGENDIAN = 0;

		public const int AV_HAVE_FAST_UNALIGNED = 1;

		public const int AV_HDR_PLUS_MAX_PAYLOAD_SIZE = 907;

		public const int AV_HWACCEL_CODEC_CAP_EXPERIMENTAL = 512;

		public const int AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH = 2;

		public const int AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH = 4;

		public const int AV_HWACCEL_FLAG_IGNORE_LEVEL = 1;

		public const int AV_HWACCEL_FLAG_UNSAFE_OUTPUT = 8;

		public const int AV_INPUT_BUFFER_PADDING_SIZE = 64;

		public const int AV_LEVEL_UNKNOWN = -99;

		public const int AV_LOG_DEBUG = 48;

		public const int AV_LOG_ERROR = 16;

		public const int AV_LOG_FATAL = 8;

		public const int AV_LOG_INFO = 32;

		public const int AV_LOG_MAX_OFFSET = 64;

		public const int AV_LOG_PANIC = 0;

		public const int AV_LOG_PRINT_DATETIME = 8;

		public const int AV_LOG_PRINT_LEVEL = 2;

		public const int AV_LOG_PRINT_TIME = 4;

		public const int AV_LOG_QUIET = -8;

		public const int AV_LOG_SKIP_REPEATED = 1;

		public const int AV_LOG_TRACE = 56;

		public const int AV_LOG_VERBOSE = 40;

		public const int AV_LOG_WARNING = 24;

		public static readonly long AV_NOPTS_VALUE;

		public const int AV_NUM_DATA_POINTERS = 8;

		public const int AV_OPT_ALLOW_NULL = 4;

		public const int AV_OPT_ARRAY_REPLACE = 8;

		public const int AV_OPT_FLAG_AUDIO_PARAM = 8;

		public const int AV_OPT_FLAG_BSF_PARAM = 256;

		public const int AV_OPT_FLAG_CHILD_CONSTS = 262144;

		public const int AV_OPT_FLAG_DECODING_PARAM = 2;

		public const int AV_OPT_FLAG_DEPRECATED = 131072;

		public const int AV_OPT_FLAG_ENCODING_PARAM = 1;

		public const int AV_OPT_FLAG_EXPORT = 64;

		public const int AV_OPT_FLAG_FILTERING_PARAM = 65536;

		public const int AV_OPT_FLAG_READONLY = 128;

		public const int AV_OPT_FLAG_RUNTIME_PARAM = 32768;

		public const int AV_OPT_FLAG_SUBTITLE_PARAM = 32;

		public const int AV_OPT_FLAG_VIDEO_PARAM = 16;

		public const int AV_OPT_MULTI_COMPONENT_RANGE = 4096;

		public const int AV_OPT_SEARCH_CHILDREN = 1;

		public const int AV_OPT_SEARCH_FAKE_OBJ = 2;

		public const int AV_OPT_SERIALIZE_OPT_FLAGS_EXACT = 2;

		public const int AV_OPT_SERIALIZE_SEARCH_CHILDREN = 4;

		public const int AV_OPT_SERIALIZE_SKIP_DEFAULTS = 1;

		public const int AV_PARSER_PTS_NB = 4;

		public const int AV_PIX_FMT_FLAG_ALPHA = 128;

		public const int AV_PIX_FMT_FLAG_BAYER = 256;

		public const int AV_PIX_FMT_FLAG_BE = 1;

		public const int AV_PIX_FMT_FLAG_BITSTREAM = 4;

		public const int AV_PIX_FMT_FLAG_FLOAT = 512;

		public const int AV_PIX_FMT_FLAG_HWACCEL = 8;

		public const int AV_PIX_FMT_FLAG_PAL = 2;

		public const int AV_PIX_FMT_FLAG_PLANAR = 16;

		public const int AV_PIX_FMT_FLAG_RGB = 32;

		public const int AV_PIX_FMT_FLAG_XYZ = 1024;

		public const int AV_PKT_FLAG_CORRUPT = 2;

		public const int AV_PKT_FLAG_DISCARD = 4;

		public const int AV_PKT_FLAG_DISPOSABLE = 16;

		public const int AV_PKT_FLAG_KEY = 1;

		public const int AV_PKT_FLAG_TRUSTED = 8;

		public const int AV_PROFILE_AAC_ELD = 38;

		public const int AV_PROFILE_AAC_HE = 4;

		public const int AV_PROFILE_AAC_HE_V2 = 28;

		public const int AV_PROFILE_AAC_LD = 22;

		public const int AV_PROFILE_AAC_LOW = 1;

		public const int AV_PROFILE_AAC_LTP = 3;

		public const int AV_PROFILE_AAC_MAIN = 0;

		public const int AV_PROFILE_AAC_SSR = 2;

		public const int AV_PROFILE_AAC_USAC = 41;

		public const int AV_PROFILE_APV_400_10 = 99;

		public const int AV_PROFILE_APV_422_10 = 33;

		public const int AV_PROFILE_APV_422_12 = 44;

		public const int AV_PROFILE_APV_444_10 = 55;

		public const int AV_PROFILE_APV_444_12 = 66;

		public const int AV_PROFILE_APV_4444_10 = 77;

		public const int AV_PROFILE_APV_4444_12 = 88;

		public const int AV_PROFILE_ARIB_PROFILE_A = 0;

		public const int AV_PROFILE_ARIB_PROFILE_C = 1;

		public const int AV_PROFILE_AV1_HIGH = 1;

		public const int AV_PROFILE_AV1_MAIN = 0;

		public const int AV_PROFILE_AV1_PROFESSIONAL = 2;

		public const int AV_PROFILE_DNXHD = 0;

		public const int AV_PROFILE_DNXHR_444 = 5;

		public const int AV_PROFILE_DNXHR_HQ = 3;

		public const int AV_PROFILE_DNXHR_HQX = 4;

		public const int AV_PROFILE_DNXHR_LB = 1;

		public const int AV_PROFILE_DNXHR_SQ = 2;

		public const int AV_PROFILE_DTS = 20;

		public const int AV_PROFILE_DTS_96_24 = 40;

		public const int AV_PROFILE_DTS_ES = 30;

		public const int AV_PROFILE_DTS_EXPRESS = 70;

		public const int AV_PROFILE_DTS_HD_HRA = 50;

		public const int AV_PROFILE_DTS_HD_MA = 60;

		public const int AV_PROFILE_DTS_HD_MA_X = 61;

		public const int AV_PROFILE_DTS_HD_MA_X_IMAX = 62;

		public const int AV_PROFILE_EAC3_DDP_ATMOS = 30;

		public const int AV_PROFILE_EVC_BASELINE = 0;

		public const int AV_PROFILE_EVC_MAIN = 1;

		public const int AV_PROFILE_H264_BASELINE = 66;

		public const int AV_PROFILE_H264_CAVLC_444 = 44;

		public const int AV_PROFILE_H264_CONSTRAINED = 512;

		public const int AV_PROFILE_H264_CONSTRAINED_BASELINE = 578;

		public const int AV_PROFILE_H264_EXTENDED = 88;

		public const int AV_PROFILE_H264_HIGH = 100;

		public const int AV_PROFILE_H264_HIGH_10 = 110;

		public const int AV_PROFILE_H264_HIGH_10_INTRA = 2158;

		public const int AV_PROFILE_H264_HIGH_422 = 122;

		public const int AV_PROFILE_H264_HIGH_422_INTRA = 2170;

		public const int AV_PROFILE_H264_HIGH_444 = 144;

		public const int AV_PROFILE_H264_HIGH_444_INTRA = 2292;

		public const int AV_PROFILE_H264_HIGH_444_PREDICTIVE = 244;

		public const int AV_PROFILE_H264_INTRA = 2048;

		public const int AV_PROFILE_H264_MAIN = 77;

		public const int AV_PROFILE_H264_MULTIVIEW_HIGH = 118;

		public const int AV_PROFILE_H264_STEREO_HIGH = 128;

		public const int AV_PROFILE_HEVC_MAIN = 1;

		public const int AV_PROFILE_HEVC_MAIN_10 = 2;

		public const int AV_PROFILE_HEVC_MAIN_STILL_PICTURE = 3;

		public const int AV_PROFILE_HEVC_MULTIVIEW_MAIN = 6;

		public const int AV_PROFILE_HEVC_REXT = 4;

		public const int AV_PROFILE_HEVC_SCC = 9;

		public const int AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION = 32768;

		public const int AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 = 1;

		public const int AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 = 2;

		public const int AV_PROFILE_JPEG2000_DCINEMA_2K = 3;

		public const int AV_PROFILE_JPEG2000_DCINEMA_4K = 4;

		public const int AV_PROFILE_KLVA_ASYNC = 1;

		public const int AV_PROFILE_KLVA_SYNC = 0;

		public const int AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT = 192;

		public const int AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT = 193;

		public const int AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS = 195;

		public const int AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT = 194;

		public const int AV_PROFILE_MJPEG_JPEG_LS = 247;

		public const int AV_PROFILE_MPEG2_422 = 0;

		public const int AV_PROFILE_MPEG2_AAC_HE = 131;

		public const int AV_PROFILE_MPEG2_AAC_LOW = 128;

		public const int AV_PROFILE_MPEG2_HIGH = 1;

		public const int AV_PROFILE_MPEG2_MAIN = 4;

		public const int AV_PROFILE_MPEG2_SIMPLE = 5;

		public const int AV_PROFILE_MPEG2_SNR_SCALABLE = 3;

		public const int AV_PROFILE_MPEG2_SS = 2;

		public const int AV_PROFILE_MPEG4_ADVANCED_CODING = 11;

		public const int AV_PROFILE_MPEG4_ADVANCED_CORE = 12;

		public const int AV_PROFILE_MPEG4_ADVANCED_REAL_TIME = 9;

		public const int AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE = 13;

		public const int AV_PROFILE_MPEG4_ADVANCED_SIMPLE = 15;

		public const int AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE = 7;

		public const int AV_PROFILE_MPEG4_CORE = 2;

		public const int AV_PROFILE_MPEG4_CORE_SCALABLE = 10;

		public const int AV_PROFILE_MPEG4_HYBRID = 8;

		public const int AV_PROFILE_MPEG4_MAIN = 3;

		public const int AV_PROFILE_MPEG4_N_BIT = 4;

		public const int AV_PROFILE_MPEG4_SCALABLE_TEXTURE = 5;

		public const int AV_PROFILE_MPEG4_SIMPLE = 0;

		public const int AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION = 6;

		public const int AV_PROFILE_MPEG4_SIMPLE_SCALABLE = 1;

		public const int AV_PROFILE_MPEG4_SIMPLE_STUDIO = 14;

		public const int AV_PROFILE_PRORES_4444 = 4;

		public const int AV_PROFILE_PRORES_HQ = 3;

		public const int AV_PROFILE_PRORES_LT = 1;

		public const int AV_PROFILE_PRORES_PROXY = 0;

		public const int AV_PROFILE_PRORES_RAW = 0;

		public const int AV_PROFILE_PRORES_RAW_HQ = 1;

		public const int AV_PROFILE_PRORES_STANDARD = 2;

		public const int AV_PROFILE_PRORES_XQ = 5;

		public const int AV_PROFILE_RESERVED = -100;

		public const int AV_PROFILE_SBC_MSBC = 1;

		public const int AV_PROFILE_TRUEHD_ATMOS = 30;

		public const int AV_PROFILE_UNKNOWN = -99;

		public const int AV_PROFILE_VC1_ADVANCED = 3;

		public const int AV_PROFILE_VC1_COMPLEX = 2;

		public const int AV_PROFILE_VC1_MAIN = 1;

		public const int AV_PROFILE_VC1_SIMPLE = 0;

		public const int AV_PROFILE_VP9_0 = 0;

		public const int AV_PROFILE_VP9_1 = 1;

		public const int AV_PROFILE_VP9_2 = 2;

		public const int AV_PROFILE_VP9_3 = 3;

		public const int AV_PROFILE_VVC_MAIN_10 = 1;

		public const int AV_PROFILE_VVC_MAIN_10_444 = 33;

		public const int AV_PROGRAM_RUNNING = 1;

		public const int AV_PTS_WRAP_ADD_OFFSET = 1;

		public const int AV_PTS_WRAP_IGNORE = 0;

		public const int AV_PTS_WRAP_SUB_OFFSET = -1;

		public const int AV_SUBTITLE_FLAG_FORCED = 1;

		public const int AV_TIME_BASE = 1000000;

		public const int AV_TIMECODE_STR_SIZE = 23;

		public const int AV_VIDEO_MAX_PLANES = 4;

		public static readonly int AVERROR_BSF_NOT_FOUND;

		public static readonly int AVERROR_BUFFER_TOO_SMALL;

		public static readonly int AVERROR_BUG;

		public static readonly int AVERROR_BUG2;

		public static readonly int AVERROR_DECODER_NOT_FOUND;

		public static readonly int AVERROR_DEMUXER_NOT_FOUND;

		public static readonly int AVERROR_ENCODER_NOT_FOUND;

		public static readonly int AVERROR_EOF;

		public static readonly int AVERROR_EXIT;

		public const int AVERROR_EXPERIMENTAL = -733130664;

		public static readonly int AVERROR_EXTERNAL;

		public static readonly int AVERROR_FILTER_NOT_FOUND;

		public static readonly int AVERROR_HTTP_BAD_REQUEST;

		public static readonly int AVERROR_HTTP_FORBIDDEN;

		public static readonly int AVERROR_HTTP_NOT_FOUND;

		public static readonly int AVERROR_HTTP_OTHER_4XX;

		public static readonly int AVERROR_HTTP_SERVER_ERROR;

		public static readonly int AVERROR_HTTP_TOO_MANY_REQUESTS;

		public static readonly int AVERROR_HTTP_UNAUTHORIZED;

		public const int AVERROR_INPUT_CHANGED = -1668179713;

		public static readonly int AVERROR_INVALIDDATA;

		public static readonly int AVERROR_MUXER_NOT_FOUND;

		public static readonly int AVERROR_OPTION_NOT_FOUND;

		public const int AVERROR_OUTPUT_CHANGED = -1668179714;

		public static readonly int AVERROR_PATCHWELCOME;

		public static readonly int AVERROR_PROTOCOL_NOT_FOUND;

		public static readonly int AVERROR_STREAM_NOT_FOUND;

		public static readonly int AVERROR_UNKNOWN;

		public const int AVFILTER_CMD_FLAG_FAST = 2;

		public const int AVFILTER_CMD_FLAG_ONE = 1;

		public const int AVFILTER_FLAG_DYNAMIC_INPUTS = 1;

		public const int AVFILTER_FLAG_DYNAMIC_OUTPUTS = 2;

		public const int AVFILTER_FLAG_HWDEVICE = 16;

		public const int AVFILTER_FLAG_METADATA_ONLY = 8;

		public const int AVFILTER_FLAG_SLICE_THREADS = 4;

		public const int AVFILTER_FLAG_SUPPORT_TIMELINE = 196608;

		public const int AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC = 65536;

		public const int AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL = 131072;

		public const int AVFILTER_THREAD_SLICE = 1;

		public const int AVFMT_AVOID_NEG_TS_AUTO = -1;

		public const int AVFMT_AVOID_NEG_TS_DISABLED = 0;

		public const int AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE = 1;

		public const int AVFMT_AVOID_NEG_TS_MAKE_ZERO = 2;

		public const int AVFMT_EVENT_FLAG_METADATA_UPDATED = 1;

		public const int AVFMT_EXPERIMENTAL = 4;

		public const int AVFMT_FLAG_AUTO_BSF = 2097152;

		public const int AVFMT_FLAG_BITEXACT = 1024;

		public const int AVFMT_FLAG_CUSTOM_IO = 128;

		public const int AVFMT_FLAG_DISCARD_CORRUPT = 256;

		public const int AVFMT_FLAG_FAST_SEEK = 524288;

		public const int AVFMT_FLAG_FLUSH_PACKETS = 512;

		public const int AVFMT_FLAG_GENPTS = 1;

		public const int AVFMT_FLAG_IGNDTS = 8;

		public const int AVFMT_FLAG_IGNIDX = 2;

		public const int AVFMT_FLAG_NOBUFFER = 64;

		public const int AVFMT_FLAG_NOFILLIN = 16;

		public const int AVFMT_FLAG_NONBLOCK = 4;

		public const int AVFMT_FLAG_NOPARSE = 32;

		public const int AVFMT_FLAG_SORT_DTS = 65536;

		public const int AVFMT_GENERIC_INDEX = 256;

		public const int AVFMT_GLOBALHEADER = 64;

		public const int AVFMT_NEEDNUMBER = 2;

		public const int AVFMT_NO_BYTE_SEEK = 32768;

		public const int AVFMT_NOBINSEARCH = 8192;

		public const int AVFMT_NODIMENSIONS = 2048;

		public const int AVFMT_NOFILE = 1;

		public const int AVFMT_NOGENSEARCH = 16384;

		public const int AVFMT_NOSTREAMS = 4096;

		public const int AVFMT_NOTIMESTAMPS = 128;

		public const int AVFMT_SEEK_TO_PTS = 67108864;

		public const int AVFMT_SHOW_IDS = 8;

		public const int AVFMT_TS_DISCONT = 512;

		public const int AVFMT_TS_NEGATIVE = 262144;

		public const int AVFMT_TS_NONSTRICT = 131072;

		public const int AVFMT_VARIABLE_FPS = 1024;

		public const int AVFMTCTX_NOHEADER = 1;

		public const int AVFMTCTX_UNSEEKABLE = 2;

		public const int AVINDEX_DISCARD_FRAME = 2;

		public const int AVINDEX_KEYFRAME = 1;

		public const int AVIO_FLAG_DIRECT = 32768;

		public const int AVIO_FLAG_NONBLOCK = 8;

		public const int AVIO_FLAG_READ = 1;

		public const int AVIO_FLAG_READ_WRITE = 3;

		public const int AVIO_FLAG_WRITE = 2;

		public const int AVIO_SEEKABLE_NORMAL = 1;

		public const int AVIO_SEEKABLE_TIME = 2;

		public const int AVPALETTE_COUNT = 256;

		public const int AVPALETTE_SIZE = 1024;

		public const int AVPROBE_PADDING_SIZE = 32;

		public const int AVPROBE_SCORE_EXTENSION = 50;

		public const int AVPROBE_SCORE_MAX = 100;

		public const int AVPROBE_SCORE_MIME_BONUS = 30;

		public const int AVPROBE_SCORE_RETRY = 25;

		public const int AVPROBE_SCORE_STREAM_RETRY = 24;

		public const int AVSEEK_FLAG_ANY = 4;

		public const int AVSEEK_FLAG_BACKWARD = 1;

		public const int AVSEEK_FLAG_BYTE = 2;

		public const int AVSEEK_FLAG_FRAME = 8;

		public const int AVSEEK_FORCE = 131072;

		public const int AVSEEK_SIZE = 65536;

		public const int AVSTREAM_EVENT_FLAG_METADATA_UPDATED = 1;

		public const int AVSTREAM_EVENT_FLAG_NEW_PACKETS = 2;

		public const int AVSTREAM_INIT_IN_INIT_OUTPUT = 1;

		public const int AVSTREAM_INIT_IN_WRITE_HEADER = 0;

		public const bool FF_API_ALSA_CHANNELS = true;

		public const bool FF_API_BUFFERSINK_OPTS = true;

		public const bool FF_API_CODEC_PROPS = true;

		public const bool FF_API_COMPUTE_PKT_FIELDS2 = true;

		public const bool FF_API_CONTEXT_PUBLIC = true;

		public const bool FF_API_EXR_GAMMA = true;

		public const bool FF_API_INIT_PACKET = true;

		public const bool FF_API_INTERNAL_TIMING = true;

		public const bool FF_API_MOD_UINTP2 = true;

		public const bool FF_API_NO_DEFAULT_TLS_VERIFY = true;

		public const bool FF_API_NVDEC_OLD_PIX_FMTS = true;

		public const bool FF_API_OPT_INT_LIST = true;

		public const bool FF_API_OPT_PTR = true;

		public const int FF_API_R_FRAME_RATE = 1;

		public const bool FF_API_RISCV_FD_ZBA = true;

		public const bool FF_API_V408_CODECID = true;

		public const bool FF_API_VULKAN_FIXED_QUEUES = true;

		public const int FF_BUG_AMV = 32;

		public const int FF_BUG_AUTODETECT = 1;

		public const int FF_BUG_DC_CLIP = 4096;

		public const int FF_BUG_DIRECT_BLOCKSIZE = 512;

		public const int FF_BUG_EDGE = 1024;

		public const int FF_BUG_HPEL_CHROMA = 2048;

		public const int FF_BUG_IEDGE = 32768;

		public const int FF_BUG_MS = 8192;

		public const int FF_BUG_NO_PADDING = 16;

		public const int FF_BUG_QPEL_CHROMA = 64;

		public const int FF_BUG_QPEL_CHROMA2 = 256;

		public const int FF_BUG_STD_QPEL = 128;

		public const int FF_BUG_TRUNCATED = 16384;

		public const int FF_BUG_UMP4 = 8;

		public const int FF_BUG_XVID_ILACE = 4;

		public const int FF_CMP_BIT = 5;

		public const int FF_CMP_CHROMA = 256;

		public const int FF_CMP_DCT = 3;

		public const int FF_CMP_DCT264 = 14;

		public const int FF_CMP_DCTMAX = 13;

		public const int FF_CMP_MEDIAN_SAD = 15;

		public const int FF_CMP_NSSE = 10;

		public const int FF_CMP_PSNR = 4;

		public const int FF_CMP_RD = 6;

		public const int FF_CMP_SAD = 0;

		public const int FF_CMP_SATD = 2;

		public const int FF_CMP_SSE = 1;

		public const int FF_CMP_VSAD = 8;

		public const int FF_CMP_VSSE = 9;

		public const int FF_CMP_W53 = 11;

		public const int FF_CMP_W97 = 12;

		public const int FF_CMP_ZERO = 7;

		public const bool FF_CODEC_OMX = true;

		public const int FF_CODEC_PROPERTY_CLOSED_CAPTIONS = 2;

		public const int FF_CODEC_PROPERTY_FILM_GRAIN = 4;

		public const int FF_CODEC_PROPERTY_LOSSLESS = 1;

		public const bool FF_CODEC_SONIC_DEC = true;

		public const bool FF_CODEC_SONIC_ENC = true;

		public const int FF_COMPLIANCE_EXPERIMENTAL = -2;

		public const int FF_COMPLIANCE_NORMAL = 0;

		public const int FF_COMPLIANCE_STRICT = 1;

		public const int FF_COMPLIANCE_UNOFFICIAL = -1;

		public const int FF_COMPLIANCE_VERY_STRICT = 2;

		public const int FF_COMPRESSION_DEFAULT = -1;

		public const int FF_DCT_ALTIVEC = 5;

		public const int FF_DCT_AUTO = 0;

		public const int FF_DCT_FAAN = 6;

		public const int FF_DCT_FASTINT = 1;

		public const int FF_DCT_INT = 2;

		public const int FF_DCT_MMX = 3;

		public const int FF_DCT_NEON = 7;

		public const int FF_DEBUG_BITSTREAM = 4;

		public const int FF_DEBUG_BUFFERS = 32768;

		public const int FF_DEBUG_BUGS = 4096;

		public const int FF_DEBUG_DCT_COEFF = 64;

		public const int FF_DEBUG_ER = 1024;

		public const int FF_DEBUG_GREEN_MD = 8388608;

		public const int FF_DEBUG_MB_TYPE = 8;

		public const int FF_DEBUG_MMCO = 2048;

		public const int FF_DEBUG_NOMC = 16777216;

		public const int FF_DEBUG_PICT_INFO = 1;

		public const int FF_DEBUG_QP = 16;

		public const int FF_DEBUG_RC = 2;

		public const int FF_DEBUG_SKIP = 128;

		public const int FF_DEBUG_STARTCODE = 256;

		public const int FF_DEBUG_THREADS = 65536;

		public const int FF_DECODE_ERROR_CONCEALMENT_ACTIVE = 4;

		public const int FF_DECODE_ERROR_DECODE_SLICES = 8;

		public const int FF_DECODE_ERROR_INVALID_BITSTREAM = 1;

		public const int FF_DECODE_ERROR_MISSING_REFERENCE = 2;

		public const int FF_EC_DEBLOCK = 2;

		public const int FF_EC_FAVOR_INTER = 256;

		public const int FF_EC_GUESS_MVS = 1;

		public const int FF_FDEBUG_TS = 1;

		public const int FF_IDCT_ALTIVEC = 8;

		public const int FF_IDCT_ARM = 7;

		public const int FF_IDCT_AUTO = 0;

		public const int FF_IDCT_FAAN = 20;

		public const int FF_IDCT_INT = 1;

		public const int FF_IDCT_SIMPLE = 2;

		public const int FF_IDCT_SIMPLEARM = 10;

		public const int FF_IDCT_SIMPLEARMV5TE = 16;

		public const int FF_IDCT_SIMPLEARMV6 = 17;

		public const int FF_IDCT_SIMPLEAUTO = 128;

		public const int FF_IDCT_SIMPLEMMX = 3;

		public const int FF_IDCT_SIMPLENEON = 22;

		public const int FF_IDCT_XVID = 14;

		public const int FF_LAMBDA_MAX = 32767;

		public const int FF_LAMBDA_SCALE = 128;

		public const int FF_LAMBDA_SHIFT = 7;

		public const int FF_LOSS_ALPHA = 8;

		public const int FF_LOSS_CHROMA = 32;

		public const int FF_LOSS_COLORQUANT = 16;

		public const int FF_LOSS_COLORSPACE = 4;

		public const int FF_LOSS_DEPTH = 2;

		public const int FF_LOSS_EXCESS_DEPTH = 128;

		public const int FF_LOSS_EXCESS_RESOLUTION = 64;

		public const int FF_LOSS_RESOLUTION = 1;

		public const int FF_MB_DECISION_BITS = 1;

		public const int FF_MB_DECISION_RD = 2;

		public const int FF_MB_DECISION_SIMPLE = 0;

		public const int FF_QP2LAMBDA = 118;

		public const int FF_QUALITY_SCALE = 128;

		public const int FF_SUB_CHARENC_MODE_AUTOMATIC = 0;

		public const int FF_SUB_CHARENC_MODE_DO_NOTHING = -1;

		public const int FF_SUB_CHARENC_MODE_IGNORE = 2;

		public const int FF_SUB_CHARENC_MODE_PRE_DECODER = 1;

		public const int FF_THREAD_FRAME = 1;

		public const int FF_THREAD_SLICE = 2;

		public static readonly int LIBAVCODEC_BUILD;

		public const string LIBAVCODEC_IDENT = "Lavc";

		public static readonly string LIBAVCODEC_VERSION;

		public static readonly int LIBAVCODEC_VERSION_INT;

		public const int LIBAVCODEC_VERSION_MAJOR = 62;

		public const int LIBAVCODEC_VERSION_MICRO = 100;

		public const int LIBAVCODEC_VERSION_MINOR = 11;

		public static readonly int LIBAVDEVICE_BUILD;

		public const string LIBAVDEVICE_IDENT = "Lavd";

		public static readonly string LIBAVDEVICE_VERSION;

		public static readonly int LIBAVDEVICE_VERSION_INT;

		public const int LIBAVDEVICE_VERSION_MAJOR = 62;

		public const int LIBAVDEVICE_VERSION_MICRO = 100;

		public const int LIBAVDEVICE_VERSION_MINOR = 1;

		public static readonly int LIBAVFILTER_BUILD;

		public const string LIBAVFILTER_IDENT = "Lavfi";

		public static readonly string LIBAVFILTER_VERSION;

		public static readonly int LIBAVFILTER_VERSION_INT;

		public const int LIBAVFILTER_VERSION_MAJOR = 11;

		public const int LIBAVFILTER_VERSION_MICRO = 100;

		public const int LIBAVFILTER_VERSION_MINOR = 4;

		public static readonly int LIBAVFORMAT_BUILD;

		public const string LIBAVFORMAT_IDENT = "Lavf";

		public static readonly string LIBAVFORMAT_VERSION;

		public static readonly int LIBAVFORMAT_VERSION_INT;

		public const int LIBAVFORMAT_VERSION_MAJOR = 62;

		public const int LIBAVFORMAT_VERSION_MICRO = 100;

		public const int LIBAVFORMAT_VERSION_MINOR = 3;

		public static readonly int LIBAVUTIL_BUILD;

		public const string LIBAVUTIL_IDENT = "Lavu";

		public static readonly string LIBAVUTIL_VERSION;

		public static readonly int LIBAVUTIL_VERSION_INT;

		public const int LIBAVUTIL_VERSION_MAJOR = 60;

		public const int LIBAVUTIL_VERSION_MICRO = 100;

		public const int LIBAVUTIL_VERSION_MINOR = 8;

		public static readonly int LIBSWRESAMPLE_BUILD;

		public const string LIBSWRESAMPLE_IDENT = "SwR";

		public static readonly string LIBSWRESAMPLE_VERSION;

		public static readonly int LIBSWRESAMPLE_VERSION_INT;

		public const int LIBSWRESAMPLE_VERSION_MAJOR = 6;

		public const int LIBSWRESAMPLE_VERSION_MICRO = 100;

		public const int LIBSWRESAMPLE_VERSION_MINOR = 1;

		public static readonly int LIBSWSCALE_BUILD;

		public const string LIBSWSCALE_IDENT = "SwS";

		public static readonly string LIBSWSCALE_VERSION;

		public static readonly int LIBSWSCALE_VERSION_INT;

		public const int LIBSWSCALE_VERSION_MAJOR = 9;

		public const int LIBSWSCALE_VERSION_MICRO = 100;

		public const int LIBSWSCALE_VERSION_MINOR = 1;

		public const double M_1_PI = 1.0 / Math.PI;

		public const float M_1_PIf = 1f / MathF.PI;

		public const double M_2_PI = 2.0 / Math.PI;

		public const float M_2_PIf = 2f / MathF.PI;

		public const double M_2_SQRTPI = 1.1283791670955126;

		public const float M_2_SQRTPIf = 1.1283792f;

		public const double M_E = Math.E;

		public const float M_Ef = MathF.E;

		public const double M_LN10 = 2.302585092994046;

		public const float M_LN10f = 2.3025851f;

		public const double M_LN2 = 0.6931471805599453;

		public const float M_LN2f = 0.6931472f;

		public const double M_LOG2_10 = 3.321928094887362;

		public const float M_LOG2_10f = 3.321928f;

		public const double M_PHI = 1.618033988749895;

		public const float M_PHIf = 1.618034f;

		public const double M_PI = Math.PI;

		public const double M_PI_2 = Math.PI / 2.0;

		public const float M_PI_2f = MathF.PI / 2f;

		public const double M_PI_4 = Math.PI / 4.0;

		public const float M_PI_4f = MathF.PI / 4f;

		public const float M_PIf = MathF.PI;

		public const double M_SQRT1_2 = 0.7071067811865476;

		public const float M_SQRT1_2f = 0.70710677f;

		public const double M_SQRT2 = 1.4142135623730951;

		public const float M_SQRT2f = 1.4142135f;

		public const int PARSER_FLAG_COMPLETE_FRAMES = 1;

		public const int PARSER_FLAG_FETCHED_OFFSET = 4;

		public const int PARSER_FLAG_ONCE = 2;

		public const int PARSER_FLAG_USE_CODEC_TS = 4096;

		public const int SLICE_FLAG_ALLOW_FIELD = 2;

		public const int SLICE_FLAG_ALLOW_PLANE = 4;

		public const int SLICE_FLAG_CODED_ORDER = 1;

		public const int SWR_FLAG_RESAMPLE = 1;

		public const int SWS_CS_BT2020 = 9;

		public const int SWS_CS_DEFAULT = 5;

		public const int SWS_CS_FCC = 4;

		public const int SWS_CS_ITU601 = 5;

		public const int SWS_CS_ITU624 = 5;

		public const int SWS_CS_ITU709 = 1;

		public const int SWS_CS_SMPTE170M = 5;

		public const int SWS_CS_SMPTE240M = 7;

		public const double SWS_MAX_REDUCE_CUTOFF = 0.002;

		public const int SWS_PARAM_DEFAULT = 123456;

		public const int SWS_SRC_V_CHR_DROP_MASK = 196608;

		public const int SWS_SRC_V_CHR_DROP_SHIFT = 16;

		public static string RootPath { get; set; }

		static ffmpeg()
		{
			ENOMEM = 12;
			EINVAL = 22;
			EPIPE = 32;
			RootPath = AppDomain.CurrentDomain.BaseDirectory;
			LibraryVersionMap = new Dictionary<string, int>
			{
				{ "avcodec", 62 },
				{ "avdevice", 62 },
				{ "avfilter", 11 },
				{ "avformat", 62 },
				{ "avutil", 60 },
				{ "swresample", 6 },
				{ "swscale", 9 }
			};
			AV_CH_BACK_CENTER = 256uL;
			AV_CH_BACK_LEFT = 16uL;
			AV_CH_BACK_RIGHT = 32uL;
			AV_CH_BINAURAL_LEFT = 2305843009213693952uL;
			AV_CH_BINAURAL_RIGHT = 4611686018427387904uL;
			AV_CH_BOTTOM_FRONT_CENTER = 274877906944uL;
			AV_CH_BOTTOM_FRONT_LEFT = 549755813888uL;
			AV_CH_BOTTOM_FRONT_RIGHT = 1099511627776uL;
			AV_CH_FRONT_CENTER = 4uL;
			AV_CH_FRONT_LEFT = 1uL;
			AV_CH_FRONT_LEFT_OF_CENTER = 64uL;
			AV_CH_FRONT_RIGHT = 2uL;
			AV_CH_FRONT_RIGHT_OF_CENTER = 128uL;
			AV_CH_LAYOUT_2_1 = AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER;
			AV_CH_LAYOUT_2_2 = AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT;
			AV_CH_LAYOUT_22POINT2 = AV_CH_LAYOUT_9POINT1POINT6 | AV_CH_BACK_CENTER | AV_CH_LOW_FREQUENCY_2 | AV_CH_TOP_FRONT_CENTER | AV_CH_TOP_CENTER | AV_CH_TOP_BACK_CENTER | AV_CH_BOTTOM_FRONT_CENTER | AV_CH_BOTTOM_FRONT_LEFT | AV_CH_BOTTOM_FRONT_RIGHT;
			AV_CH_LAYOUT_2POINT1 = AV_CH_LAYOUT_STEREO | AV_CH_LOW_FREQUENCY;
			AV_CH_LAYOUT_3POINT1 = AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY;
			AV_CH_LAYOUT_3POINT1POINT2 = AV_CH_LAYOUT_3POINT1 | AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT;
			AV_CH_LAYOUT_4POINT0 = AV_CH_LAYOUT_SURROUND | AV_CH_BACK_CENTER;
			AV_CH_LAYOUT_4POINT1 = AV_CH_LAYOUT_4POINT0 | AV_CH_LOW_FREQUENCY;
			AV_CH_LAYOUT_5POINT0 = AV_CH_LAYOUT_SURROUND | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT;
			AV_CH_LAYOUT_5POINT0_BACK = AV_CH_LAYOUT_SURROUND | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT;
			AV_CH_LAYOUT_5POINT1 = AV_CH_LAYOUT_5POINT0 | AV_CH_LOW_FREQUENCY;
			AV_CH_LAYOUT_5POINT1_BACK = AV_CH_LAYOUT_5POINT0_BACK | AV_CH_LOW_FREQUENCY;
			AV_CH_LAYOUT_5POINT1POINT2 = AV_CH_LAYOUT_5POINT1 | AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT;
			AV_CH_LAYOUT_5POINT1POINT2_BACK = AV_CH_LAYOUT_5POINT1_BACK | AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT;
			AV_CH_LAYOUT_5POINT1POINT4_BACK = AV_CH_LAYOUT_5POINT1POINT2 | AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT;
			AV_CH_LAYOUT_6POINT0 = AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_CENTER;
			AV_CH_LAYOUT_6POINT0_FRONT = AV_CH_LAYOUT_2_2 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER;
			AV_CH_LAYOUT_6POINT1 = AV_CH_LAYOUT_5POINT1 | AV_CH_BACK_CENTER;
			AV_CH_LAYOUT_6POINT1_BACK = AV_CH_LAYOUT_5POINT1_BACK | AV_CH_BACK_CENTER;
			AV_CH_LAYOUT_6POINT1_FRONT = AV_CH_LAYOUT_6POINT0_FRONT | AV_CH_LOW_FREQUENCY;
			AV_CH_LAYOUT_7POINT0 = AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT;
			AV_CH_LAYOUT_7POINT0_FRONT = AV_CH_LAYOUT_5POINT0 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER;
			AV_CH_LAYOUT_7POINT1 = AV_CH_LAYOUT_5POINT1 | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT;
			AV_CH_LAYOUT_7POINT1_TOP_BACK = AV_CH_LAYOUT_5POINT1POINT2_BACK;
			AV_CH_LAYOUT_7POINT1_WIDE = AV_CH_LAYOUT_5POINT1 | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER;
			AV_CH_LAYOUT_7POINT1_WIDE_BACK = AV_CH_LAYOUT_5POINT1_BACK | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER;
			AV_CH_LAYOUT_7POINT1POINT2 = AV_CH_LAYOUT_7POINT1 | AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT;
			AV_CH_LAYOUT_7POINT1POINT4_BACK = AV_CH_LAYOUT_7POINT1POINT2 | AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT;
			AV_CH_LAYOUT_7POINT2POINT3 = AV_CH_LAYOUT_7POINT1POINT2 | AV_CH_TOP_BACK_CENTER | AV_CH_LOW_FREQUENCY_2;
			AV_CH_LAYOUT_9POINT1POINT4_BACK = AV_CH_LAYOUT_7POINT1POINT4_BACK | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER;
			AV_CH_LAYOUT_9POINT1POINT6 = AV_CH_LAYOUT_9POINT1POINT4_BACK | AV_CH_TOP_SIDE_LEFT | AV_CH_TOP_SIDE_RIGHT;
			AV_CH_LAYOUT_BINAURAL = AV_CH_BINAURAL_LEFT | AV_CH_BINAURAL_RIGHT;
			AV_CH_LAYOUT_CUBE = AV_CH_LAYOUT_QUAD | AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT | AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT;
			AV_CH_LAYOUT_HEXADECAGONAL = AV_CH_LAYOUT_OCTAGONAL | AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT | AV_CH_TOP_BACK_LEFT | AV_CH_TOP_BACK_RIGHT | AV_CH_TOP_BACK_CENTER | AV_CH_TOP_FRONT_CENTER | AV_CH_TOP_FRONT_LEFT | AV_CH_TOP_FRONT_RIGHT;
			AV_CH_LAYOUT_HEXAGONAL = AV_CH_LAYOUT_5POINT0_BACK | AV_CH_BACK_CENTER;
			AV_CH_LAYOUT_MONO = AV_CH_FRONT_CENTER;
			AV_CH_LAYOUT_OCTAGONAL = AV_CH_LAYOUT_5POINT0 | AV_CH_BACK_LEFT | AV_CH_BACK_CENTER | AV_CH_BACK_RIGHT;
			AV_CH_LAYOUT_QUAD = AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT;
			AV_CH_LAYOUT_STEREO = AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT;
			AV_CH_LAYOUT_STEREO_DOWNMIX = AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT;
			AV_CH_LAYOUT_SURROUND = AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER;
			AV_CH_LOW_FREQUENCY = 8uL;
			AV_CH_LOW_FREQUENCY_2 = 34359738368uL;
			AV_CH_SIDE_LEFT = 512uL;
			AV_CH_SIDE_RIGHT = 1024uL;
			AV_CH_SIDE_SURROUND_LEFT = 2199023255552uL;
			AV_CH_SIDE_SURROUND_RIGHT = 4398046511104uL;
			AV_CH_STEREO_LEFT = 536870912uL;
			AV_CH_STEREO_RIGHT = 1073741824uL;
			AV_CH_SURROUND_DIRECT_LEFT = 8589934592uL;
			AV_CH_SURROUND_DIRECT_RIGHT = 17179869184uL;
			AV_CH_TOP_BACK_CENTER = 65536uL;
			AV_CH_TOP_BACK_LEFT = 32768uL;
			AV_CH_TOP_BACK_RIGHT = 131072uL;
			AV_CH_TOP_CENTER = 2048uL;
			AV_CH_TOP_FRONT_CENTER = 8192uL;
			AV_CH_TOP_FRONT_LEFT = 4096uL;
			AV_CH_TOP_FRONT_RIGHT = 16384uL;
			AV_CH_TOP_SIDE_LEFT = 68719476736uL;
			AV_CH_TOP_SIDE_RIGHT = 137438953472uL;
			AV_CH_TOP_SURROUND_LEFT = 8796093022208uL;
			AV_CH_TOP_SURROUND_RIGHT = 17592186044416uL;
			AV_CH_WIDE_LEFT = 2147483648uL;
			AV_CH_WIDE_RIGHT = 4294967296uL;
			AV_CODEC_ID_H265 = 173;
			AV_CODEC_ID_H266 = 196;
			AV_CODEC_ID_IFF_BYTERUN1 = 136;
			AV_NOPTS_VALUE = (long)UINT64_C(9223372036854775808uL);
			AVERROR_BSF_NOT_FOUND = FFERRTAG(248, 'B', 'S', 'F');
			AVERROR_BUFFER_TOO_SMALL = FFERRTAG('B', 'U', 'F', 'S');
			AVERROR_BUG = FFERRTAG('B', 'U', 'G', '!');
			AVERROR_BUG2 = FFERRTAG('B', 'U', 'G', ' ');
			AVERROR_DECODER_NOT_FOUND = FFERRTAG(248, 'D', 'E', 'C');
			AVERROR_DEMUXER_NOT_FOUND = FFERRTAG(248, 'D', 'E', 'M');
			AVERROR_ENCODER_NOT_FOUND = FFERRTAG(248, 'E', 'N', 'C');
			AVERROR_EOF = FFERRTAG('E', 'O', 'F', ' ');
			AVERROR_EXIT = FFERRTAG('E', 'X', 'I', 'T');
			AVERROR_EXTERNAL = FFERRTAG('E', 'X', 'T', ' ');
			AVERROR_FILTER_NOT_FOUND = FFERRTAG(248, 'F', 'I', 'L');
			AVERROR_HTTP_BAD_REQUEST = FFERRTAG(248, '4', '0', '0');
			AVERROR_HTTP_FORBIDDEN = FFERRTAG(248, '4', '0', '3');
			AVERROR_HTTP_NOT_FOUND = FFERRTAG(248, '4', '0', '4');
			AVERROR_HTTP_OTHER_4XX = FFERRTAG(248, '4', 'X', 'X');
			AVERROR_HTTP_SERVER_ERROR = FFERRTAG(248, '5', 'X', 'X');
			AVERROR_HTTP_TOO_MANY_REQUESTS = FFERRTAG(248, '4', '2', '9');
			AVERROR_HTTP_UNAUTHORIZED = FFERRTAG(248, '4', '0', '1');
			AVERROR_INVALIDDATA = FFERRTAG('I', 'N', 'D', 'A');
			AVERROR_MUXER_NOT_FOUND = FFERRTAG(248, 'M', 'U', 'X');
			AVERROR_OPTION_NOT_FOUND = FFERRTAG(248, 'O', 'P', 'T');
			AVERROR_PATCHWELCOME = FFERRTAG('P', 'A', 'W', 'E');
			AVERROR_PROTOCOL_NOT_FOUND = FFERRTAG(248, 'P', 'R', 'O');
			AVERROR_STREAM_NOT_FOUND = FFERRTAG(248, 'S', 'T', 'R');
			AVERROR_UNKNOWN = FFERRTAG('U', 'N', 'K', 'N');
			LIBAVCODEC_BUILD = LIBAVCODEC_VERSION_INT;
			LIBAVCODEC_VERSION = AV_VERSION(62, 11, 100);
			LIBAVCODEC_VERSION_INT = AV_VERSION_INT(62, 11, 100);
			LIBAVDEVICE_BUILD = LIBAVDEVICE_VERSION_INT;
			LIBAVDEVICE_VERSION = AV_VERSION(62, 1, 100);
			LIBAVDEVICE_VERSION_INT = AV_VERSION_INT(62, 1, 100);
			LIBAVFILTER_BUILD = LIBAVFILTER_VERSION_INT;
			LIBAVFILTER_VERSION = AV_VERSION(11, 4, 100);
			LIBAVFILTER_VERSION_INT = AV_VERSION_INT(11, 4, 100);
			LIBAVFORMAT_BUILD = LIBAVFORMAT_VERSION_INT;
			LIBAVFORMAT_VERSION = AV_VERSION(62, 3, 100);
			LIBAVFORMAT_VERSION_INT = AV_VERSION_INT(62, 3, 100);
			LIBAVUTIL_BUILD = LIBAVUTIL_VERSION_INT;
			LIBAVUTIL_VERSION = AV_VERSION(60, 8, 100);
			LIBAVUTIL_VERSION_INT = AV_VERSION_INT(60, 8, 100);
			LIBSWRESAMPLE_BUILD = LIBSWRESAMPLE_VERSION_INT;
			LIBSWRESAMPLE_VERSION = AV_VERSION(6, 1, 100);
			LIBSWRESAMPLE_VERSION_INT = AV_VERSION_INT(6, 1, 100);
			LIBSWSCALE_BUILD = LIBSWSCALE_VERSION_INT;
			LIBSWSCALE_VERSION = AV_VERSION(9, 1, 100);
			LIBSWSCALE_VERSION_INT = AV_VERSION_INT(9, 1, 100);
			int eAGAIN = ((FunctionResolverFactory.GetPlatformId() != PlatformID.MacOSX) ? 11 : 35);
			EAGAIN = eAGAIN;
			DynamicallyLoadedBindings.Initialize();
		}

		public static ulong UINT64_C<T>(T a)
		{
			return Convert.ToUInt64(a);
		}

		public static int AVERROR<T1>(T1 a)
		{
			return -Convert.ToInt32(a);
		}

		public static int MKTAG<T1, T2, T3, T4>(T1 a, T2 b, T3 c, T4 d)
		{
			return (int)(Convert.ToUInt32(a) | (Convert.ToUInt32(b) << 8) | (Convert.ToUInt32(c) << 16) | (Convert.ToUInt32(d) << 24));
		}

		public static int FFERRTAG<T1, T2, T3, T4>(T1 a, T2 b, T3 c, T4 d)
		{
			return -MKTAG(a, b, c, d);
		}

		public static int AV_VERSION_INT<T1, T2, T3>(T1 a, T2 b, T3 c)
		{
			return (Convert.ToInt32(a) << 16) | (Convert.ToInt32(b) << 8) | Convert.ToInt32(c);
		}

		public static string AV_VERSION_DOT<T1, T2, T3>(T1 a, T2 b, T3 c)
		{
			return $"{a}.{b}.{c}";
		}

		public static string AV_VERSION<T1, T2, T3>(T1 a, T2 b, T3 c)
		{
			return AV_VERSION_DOT(a, b, c);
		}

		public unsafe static int av_add_index_entry(AVStream* st, long pos, long timestamp, int size, int distance, int flags)
		{
			return vectors.av_add_index_entry(st, pos, timestamp, size, distance, flags);
		}

		public static AVRational av_add_q(AVRational b, AVRational c)
		{
			return vectors.av_add_q(b, c);
		}

		public static long av_add_stable(AVRational ts_tb, long ts, AVRational inc_tb, long inc)
		{
			return vectors.av_add_stable(ts_tb, ts, inc_tb, inc);
		}

		public unsafe static int av_append_packet(AVIOContext* s, AVPacket* pkt, int size)
		{
			return vectors.av_append_packet(s, pkt, size);
		}

		public unsafe static AVAudioFifo* av_audio_fifo_alloc(AVSampleFormat sample_fmt, int channels, int nb_samples)
		{
			return vectors.av_audio_fifo_alloc(sample_fmt, channels, nb_samples);
		}

		public unsafe static int av_audio_fifo_drain(AVAudioFifo* af, int nb_samples)
		{
			return vectors.av_audio_fifo_drain(af, nb_samples);
		}

		public unsafe static void av_audio_fifo_free(AVAudioFifo* af)
		{
			vectors.av_audio_fifo_free(af);
		}

		public unsafe static int av_audio_fifo_peek(AVAudioFifo* af, void** data, int nb_samples)
		{
			return vectors.av_audio_fifo_peek(af, data, nb_samples);
		}

		public unsafe static int av_audio_fifo_peek_at(AVAudioFifo* af, void** data, int nb_samples, int offset)
		{
			return vectors.av_audio_fifo_peek_at(af, data, nb_samples, offset);
		}

		public unsafe static int av_audio_fifo_read(AVAudioFifo* af, void** data, int nb_samples)
		{
			return vectors.av_audio_fifo_read(af, data, nb_samples);
		}

		public unsafe static int av_audio_fifo_realloc(AVAudioFifo* af, int nb_samples)
		{
			return vectors.av_audio_fifo_realloc(af, nb_samples);
		}

		public unsafe static void av_audio_fifo_reset(AVAudioFifo* af)
		{
			vectors.av_audio_fifo_reset(af);
		}

		public unsafe static int av_audio_fifo_size(AVAudioFifo* af)
		{
			return vectors.av_audio_fifo_size(af);
		}

		public unsafe static int av_audio_fifo_space(AVAudioFifo* af)
		{
			return vectors.av_audio_fifo_space(af);
		}

		public unsafe static int av_audio_fifo_write(AVAudioFifo* af, void** data, int nb_samples)
		{
			return vectors.av_audio_fifo_write(af, data, nb_samples);
		}

		public static double av_bessel_i0(double x)
		{
			return vectors.av_bessel_i0(x);
		}

		public unsafe static int av_bsf_alloc(AVBitStreamFilter* filter, AVBSFContext** ctx)
		{
			return vectors.av_bsf_alloc(filter, ctx);
		}

		public unsafe static void av_bsf_flush(AVBSFContext* ctx)
		{
			vectors.av_bsf_flush(ctx);
		}

		public unsafe static void av_bsf_free(AVBSFContext** ctx)
		{
			vectors.av_bsf_free(ctx);
		}

		public unsafe static AVBitStreamFilter* av_bsf_get_by_name(string name)
		{
			return vectors.av_bsf_get_by_name(name);
		}

		public unsafe static AVClass* av_bsf_get_class()
		{
			return vectors.av_bsf_get_class();
		}

		public unsafe static int av_bsf_get_null_filter(AVBSFContext** bsf)
		{
			return vectors.av_bsf_get_null_filter(bsf);
		}

		public unsafe static int av_bsf_init(AVBSFContext* ctx)
		{
			return vectors.av_bsf_init(ctx);
		}

		public unsafe static AVBitStreamFilter* av_bsf_iterate(void** opaque)
		{
			return vectors.av_bsf_iterate(opaque);
		}

		public unsafe static AVBSFList* av_bsf_list_alloc()
		{
			return vectors.av_bsf_list_alloc();
		}

		public unsafe static int av_bsf_list_append(AVBSFList* lst, AVBSFContext* bsf)
		{
			return vectors.av_bsf_list_append(lst, bsf);
		}

		public unsafe static int av_bsf_list_append2(AVBSFList* lst, string bsf_name, AVDictionary** options)
		{
			return vectors.av_bsf_list_append2(lst, bsf_name, options);
		}

		public unsafe static int av_bsf_list_finalize(AVBSFList** lst, AVBSFContext** bsf)
		{
			return vectors.av_bsf_list_finalize(lst, bsf);
		}

		public unsafe static void av_bsf_list_free(AVBSFList** lst)
		{
			vectors.av_bsf_list_free(lst);
		}

		public unsafe static int av_bsf_list_parse_str(string str, AVBSFContext** bsf)
		{
			return vectors.av_bsf_list_parse_str(str, bsf);
		}

		public unsafe static int av_bsf_receive_packet(AVBSFContext* ctx, AVPacket* pkt)
		{
			return vectors.av_bsf_receive_packet(ctx, pkt);
		}

		public unsafe static int av_bsf_send_packet(AVBSFContext* ctx, AVPacket* pkt)
		{
			return vectors.av_bsf_send_packet(ctx, pkt);
		}

		public unsafe static AVBufferRef* av_buffer_alloc(ulong size)
		{
			return vectors.av_buffer_alloc(size);
		}

		public unsafe static AVBufferRef* av_buffer_allocz(ulong size)
		{
			return vectors.av_buffer_allocz(size);
		}

		public unsafe static AVBufferRef* av_buffer_create(byte* data, ulong size, av_buffer_create_free_func free, void* opaque, int flags)
		{
			return vectors.av_buffer_create(data, size, free, opaque, flags);
		}

		public unsafe static void av_buffer_default_free(void* opaque, byte* data)
		{
			vectors.av_buffer_default_free(opaque, data);
		}

		public unsafe static void* av_buffer_get_opaque(AVBufferRef* buf)
		{
			return vectors.av_buffer_get_opaque(buf);
		}

		public unsafe static int av_buffer_get_ref_count(AVBufferRef* buf)
		{
			return vectors.av_buffer_get_ref_count(buf);
		}

		public unsafe static int av_buffer_is_writable(AVBufferRef* buf)
		{
			return vectors.av_buffer_is_writable(buf);
		}

		public unsafe static int av_buffer_make_writable(AVBufferRef** buf)
		{
			return vectors.av_buffer_make_writable(buf);
		}

		public unsafe static void* av_buffer_pool_buffer_get_opaque(AVBufferRef* @ref)
		{
			return vectors.av_buffer_pool_buffer_get_opaque(@ref);
		}

		public unsafe static AVBufferRef* av_buffer_pool_get(AVBufferPool* pool)
		{
			return vectors.av_buffer_pool_get(pool);
		}

		public unsafe static AVBufferPool* av_buffer_pool_init(ulong size, av_buffer_pool_init_alloc_func alloc)
		{
			return vectors.av_buffer_pool_init(size, alloc);
		}

		public unsafe static AVBufferPool* av_buffer_pool_init2(ulong size, void* opaque, av_buffer_pool_init2_alloc_func alloc, av_buffer_pool_init2_pool_free_func pool_free)
		{
			return vectors.av_buffer_pool_init2(size, opaque, alloc, pool_free);
		}

		public unsafe static void av_buffer_pool_uninit(AVBufferPool** pool)
		{
			vectors.av_buffer_pool_uninit(pool);
		}

		public unsafe static int av_buffer_realloc(AVBufferRef** buf, ulong size)
		{
			return vectors.av_buffer_realloc(buf, size);
		}

		public unsafe static AVBufferRef* av_buffer_ref(AVBufferRef* buf)
		{
			return vectors.av_buffer_ref(buf);
		}

		public unsafe static int av_buffer_replace(AVBufferRef** dst, AVBufferRef* src)
		{
			return vectors.av_buffer_replace(dst, src);
		}

		public unsafe static void av_buffer_unref(AVBufferRef** buf)
		{
			vectors.av_buffer_unref(buf);
		}

		public unsafe static int av_buffersink_get_ch_layout(AVFilterContext* ctx, AVChannelLayout* ch_layout)
		{
			return vectors.av_buffersink_get_ch_layout(ctx, ch_layout);
		}

		public unsafe static int av_buffersink_get_channels(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_channels(ctx);
		}

		public unsafe static AVColorRange av_buffersink_get_color_range(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_color_range(ctx);
		}

		public unsafe static AVColorSpace av_buffersink_get_colorspace(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_colorspace(ctx);
		}

		public unsafe static int av_buffersink_get_format(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_format(ctx);
		}

		public unsafe static int av_buffersink_get_frame(AVFilterContext* ctx, AVFrame* frame)
		{
			return vectors.av_buffersink_get_frame(ctx, frame);
		}

		public unsafe static int av_buffersink_get_frame_flags(AVFilterContext* ctx, AVFrame* frame, int flags)
		{
			return vectors.av_buffersink_get_frame_flags(ctx, frame, flags);
		}

		public unsafe static AVRational av_buffersink_get_frame_rate(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_frame_rate(ctx);
		}

		public unsafe static int av_buffersink_get_h(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_h(ctx);
		}

		public unsafe static AVBufferRef* av_buffersink_get_hw_frames_ctx(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_hw_frames_ctx(ctx);
		}

		public unsafe static AVRational av_buffersink_get_sample_aspect_ratio(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_sample_aspect_ratio(ctx);
		}

		public unsafe static int av_buffersink_get_sample_rate(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_sample_rate(ctx);
		}

		public unsafe static int av_buffersink_get_samples(AVFilterContext* ctx, AVFrame* frame, int nb_samples)
		{
			return vectors.av_buffersink_get_samples(ctx, frame, nb_samples);
		}

		public unsafe static AVFrameSideData** av_buffersink_get_side_data(AVFilterContext* ctx, int* nb_side_data)
		{
			return vectors.av_buffersink_get_side_data(ctx, nb_side_data);
		}

		public unsafe static AVRational av_buffersink_get_time_base(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_time_base(ctx);
		}

		public unsafe static AVMediaType av_buffersink_get_type(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_type(ctx);
		}

		public unsafe static int av_buffersink_get_w(AVFilterContext* ctx)
		{
			return vectors.av_buffersink_get_w(ctx);
		}

		public unsafe static void av_buffersink_set_frame_size(AVFilterContext* ctx, uint frame_size)
		{
			vectors.av_buffersink_set_frame_size(ctx, frame_size);
		}

		public unsafe static int av_buffersrc_add_frame(AVFilterContext* ctx, AVFrame* frame)
		{
			return vectors.av_buffersrc_add_frame(ctx, frame);
		}

		public unsafe static int av_buffersrc_add_frame_flags(AVFilterContext* buffer_src, AVFrame* frame, int flags)
		{
			return vectors.av_buffersrc_add_frame_flags(buffer_src, frame, flags);
		}

		public unsafe static int av_buffersrc_close(AVFilterContext* ctx, long pts, uint flags)
		{
			return vectors.av_buffersrc_close(ctx, pts, flags);
		}

		public unsafe static uint av_buffersrc_get_nb_failed_requests(AVFilterContext* buffer_src)
		{
			return vectors.av_buffersrc_get_nb_failed_requests(buffer_src);
		}

		public unsafe static AVBufferSrcParameters* av_buffersrc_parameters_alloc()
		{
			return vectors.av_buffersrc_parameters_alloc();
		}

		public unsafe static int av_buffersrc_parameters_set(AVFilterContext* ctx, AVBufferSrcParameters* param)
		{
			return vectors.av_buffersrc_parameters_set(ctx, param);
		}

		public unsafe static int av_buffersrc_write_frame(AVFilterContext* ctx, AVFrame* frame)
		{
			return vectors.av_buffersrc_write_frame(ctx, frame);
		}

		public unsafe static void* av_calloc(ulong nmemb, ulong size)
		{
			return vectors.av_calloc(nmemb, size);
		}

		public unsafe static int av_channel_description(byte* buf, ulong buf_size, AVChannel channel)
		{
			return vectors.av_channel_description(buf, buf_size, channel);
		}

		public unsafe static void av_channel_description_bprint(AVBPrint* bp, AVChannel channel_id)
		{
			vectors.av_channel_description_bprint(bp, channel_id);
		}

		public static AVChannel av_channel_from_string(string name)
		{
			return vectors.av_channel_from_string(name);
		}

		public unsafe static int av_channel_layout_ambisonic_order(AVChannelLayout* channel_layout)
		{
			return vectors.av_channel_layout_ambisonic_order(channel_layout);
		}

		public unsafe static AVChannel av_channel_layout_channel_from_index(AVChannelLayout* channel_layout, uint idx)
		{
			return vectors.av_channel_layout_channel_from_index(channel_layout, idx);
		}

		public unsafe static AVChannel av_channel_layout_channel_from_string(AVChannelLayout* channel_layout, string name)
		{
			return vectors.av_channel_layout_channel_from_string(channel_layout, name);
		}

		public unsafe static int av_channel_layout_check(AVChannelLayout* channel_layout)
		{
			return vectors.av_channel_layout_check(channel_layout);
		}

		public unsafe static int av_channel_layout_compare(AVChannelLayout* chl, AVChannelLayout* chl1)
		{
			return vectors.av_channel_layout_compare(chl, chl1);
		}

		public unsafe static int av_channel_layout_copy(AVChannelLayout* dst, AVChannelLayout* src)
		{
			return vectors.av_channel_layout_copy(dst, src);
		}

		public unsafe static int av_channel_layout_custom_init(AVChannelLayout* channel_layout, int nb_channels)
		{
			return vectors.av_channel_layout_custom_init(channel_layout, nb_channels);
		}

		public unsafe static void av_channel_layout_default(AVChannelLayout* ch_layout, int nb_channels)
		{
			vectors.av_channel_layout_default(ch_layout, nb_channels);
		}

		public unsafe static int av_channel_layout_describe(AVChannelLayout* channel_layout, byte* buf, ulong buf_size)
		{
			return vectors.av_channel_layout_describe(channel_layout, buf, buf_size);
		}

		public unsafe static int av_channel_layout_describe_bprint(AVChannelLayout* channel_layout, AVBPrint* bp)
		{
			return vectors.av_channel_layout_describe_bprint(channel_layout, bp);
		}

		public unsafe static int av_channel_layout_from_mask(AVChannelLayout* channel_layout, ulong mask)
		{
			return vectors.av_channel_layout_from_mask(channel_layout, mask);
		}

		public unsafe static int av_channel_layout_from_string(AVChannelLayout* channel_layout, string str)
		{
			return vectors.av_channel_layout_from_string(channel_layout, str);
		}

		public unsafe static int av_channel_layout_index_from_channel(AVChannelLayout* channel_layout, AVChannel channel)
		{
			return vectors.av_channel_layout_index_from_channel(channel_layout, channel);
		}

		public unsafe static int av_channel_layout_index_from_string(AVChannelLayout* channel_layout, string name)
		{
			return vectors.av_channel_layout_index_from_string(channel_layout, name);
		}

		public unsafe static int av_channel_layout_retype(AVChannelLayout* channel_layout, AVChannelOrder order, int flags)
		{
			return vectors.av_channel_layout_retype(channel_layout, order, flags);
		}

		public unsafe static AVChannelLayout* av_channel_layout_standard(void** opaque)
		{
			return vectors.av_channel_layout_standard(opaque);
		}

		public unsafe static ulong av_channel_layout_subset(AVChannelLayout* channel_layout, ulong mask)
		{
			return vectors.av_channel_layout_subset(channel_layout, mask);
		}

		public unsafe static void av_channel_layout_uninit(AVChannelLayout* channel_layout)
		{
			vectors.av_channel_layout_uninit(channel_layout);
		}

		public unsafe static int av_channel_name(byte* buf, ulong buf_size, AVChannel channel)
		{
			return vectors.av_channel_name(buf, buf_size, channel);
		}

		public unsafe static void av_channel_name_bprint(AVBPrint* bp, AVChannel channel_id)
		{
			vectors.av_channel_name_bprint(bp, channel_id);
		}

		public unsafe static int av_chroma_location_enum_to_pos(int* xpos, int* ypos, AVChromaLocation pos)
		{
			return vectors.av_chroma_location_enum_to_pos(xpos, ypos, pos);
		}

		public static int av_chroma_location_from_name(string name)
		{
			return vectors.av_chroma_location_from_name(name);
		}

		public static string av_chroma_location_name(AVChromaLocation location)
		{
			return vectors.av_chroma_location_name(location);
		}

		public static AVChromaLocation av_chroma_location_pos_to_enum(int xpos, int ypos)
		{
			return vectors.av_chroma_location_pos_to_enum(xpos, ypos);
		}

		public unsafe static AVCodecID av_codec_get_id(AVCodecTag** tags, uint tag)
		{
			return vectors.av_codec_get_id(tags, tag);
		}

		public unsafe static uint av_codec_get_tag(AVCodecTag** tags, AVCodecID id)
		{
			return vectors.av_codec_get_tag(tags, id);
		}

		public unsafe static int av_codec_get_tag2(AVCodecTag** tags, AVCodecID id, uint* tag)
		{
			return vectors.av_codec_get_tag2(tags, id, tag);
		}

		public unsafe static int av_codec_is_decoder(AVCodec* codec)
		{
			return vectors.av_codec_is_decoder(codec);
		}

		public unsafe static int av_codec_is_encoder(AVCodec* codec)
		{
			return vectors.av_codec_is_encoder(codec);
		}

		public unsafe static AVCodec* av_codec_iterate(void** opaque)
		{
			return vectors.av_codec_iterate(opaque);
		}

		public static int av_color_primaries_from_name(string name)
		{
			return vectors.av_color_primaries_from_name(name);
		}

		public static string av_color_primaries_name(AVColorPrimaries primaries)
		{
			return vectors.av_color_primaries_name(primaries);
		}

		public static int av_color_range_from_name(string name)
		{
			return vectors.av_color_range_from_name(name);
		}

		public static string av_color_range_name(AVColorRange range)
		{
			return vectors.av_color_range_name(range);
		}

		public static int av_color_space_from_name(string name)
		{
			return vectors.av_color_space_from_name(name);
		}

		public static string av_color_space_name(AVColorSpace space)
		{
			return vectors.av_color_space_name(space);
		}

		public static int av_color_transfer_from_name(string name)
		{
			return vectors.av_color_transfer_from_name(name);
		}

		public static string av_color_transfer_name(AVColorTransferCharacteristic transfer)
		{
			return vectors.av_color_transfer_name(transfer);
		}

		public static long av_compare_mod(ulong a, ulong b, ulong mod)
		{
			return vectors.av_compare_mod(a, b, mod);
		}

		public static int av_compare_ts(long ts_a, AVRational tb_a, long ts_b, AVRational tb_b)
		{
			return vectors.av_compare_ts(ts_a, tb_a, ts_b, tb_b);
		}

		public unsafe static AVContainerFifo* av_container_fifo_alloc_avpacket(uint flags)
		{
			return vectors.av_container_fifo_alloc_avpacket(flags);
		}

		public unsafe static AVContentLightMetadata* av_content_light_metadata_alloc(ulong* size)
		{
			return vectors.av_content_light_metadata_alloc(size);
		}

		public unsafe static AVContentLightMetadata* av_content_light_metadata_create_side_data(AVFrame* frame)
		{
			return vectors.av_content_light_metadata_create_side_data(frame);
		}

		public unsafe static AVCPBProperties* av_cpb_properties_alloc(ulong* size)
		{
			return vectors.av_cpb_properties_alloc(size);
		}

		public static int av_cpu_count()
		{
			return vectors.av_cpu_count();
		}

		public static void av_cpu_force_count(int count)
		{
			vectors.av_cpu_force_count(count);
		}

		public static ulong av_cpu_max_align()
		{
			return vectors.av_cpu_max_align();
		}

		public static AVRational av_d2q(double d, int max)
		{
			return vectors.av_d2q(d, max);
		}

		public unsafe static AVD3D11VAContext* av_d3d11va_alloc_context()
		{
			return vectors.av_d3d11va_alloc_context();
		}

		public unsafe static AVClassCategory av_default_get_category(void* ptr)
		{
			return vectors.av_default_get_category(ptr);
		}

		public unsafe static string av_default_item_name(void* ctx)
		{
			return vectors.av_default_item_name(ctx);
		}

		public unsafe static AVInputFormat* av_demuxer_iterate(void** opaque)
		{
			return vectors.av_demuxer_iterate(opaque);
		}

		public unsafe static int av_dict_copy(AVDictionary** dst, AVDictionary* src, int flags)
		{
			return vectors.av_dict_copy(dst, src, flags);
		}

		public unsafe static int av_dict_count(AVDictionary* m)
		{
			return vectors.av_dict_count(m);
		}

		public unsafe static void av_dict_free(AVDictionary** m)
		{
			vectors.av_dict_free(m);
		}

		public unsafe static AVDictionaryEntry* av_dict_get(AVDictionary* m, string key, AVDictionaryEntry* prev, int flags)
		{
			return vectors.av_dict_get(m, key, prev, flags);
		}

		public unsafe static int av_dict_get_string(AVDictionary* m, byte** buffer, byte key_val_sep, byte pairs_sep)
		{
			return vectors.av_dict_get_string(m, buffer, key_val_sep, pairs_sep);
		}

		public unsafe static AVDictionaryEntry* av_dict_iterate(AVDictionary* m, AVDictionaryEntry* prev)
		{
			return vectors.av_dict_iterate(m, prev);
		}

		public unsafe static int av_dict_parse_string(AVDictionary** pm, string str, string key_val_sep, string pairs_sep, int flags)
		{
			return vectors.av_dict_parse_string(pm, str, key_val_sep, pairs_sep, flags);
		}

		public unsafe static int av_dict_set(AVDictionary** pm, string key, string value, int flags)
		{
			return vectors.av_dict_set(pm, key, value, flags);
		}

		public unsafe static int av_dict_set_int(AVDictionary** pm, string key, long value, int flags)
		{
			return vectors.av_dict_set_int(pm, key, value, flags);
		}

		public static void av_display_matrix_flip(ref int_array9 matrix, int hflip, int vflip)
		{
			vectors.av_display_matrix_flip(ref matrix, hflip, vflip);
		}

		public static double av_display_rotation_get(in int_array9 matrix)
		{
			return vectors.av_display_rotation_get(in matrix);
		}

		public static void av_display_rotation_set(ref int_array9 matrix, double angle)
		{
			vectors.av_display_rotation_set(ref matrix, angle);
		}

		public static int av_disposition_from_string(string disp)
		{
			return vectors.av_disposition_from_string(disp);
		}

		public static string av_disposition_to_string(int disposition)
		{
			return vectors.av_disposition_to_string(disposition);
		}

		public static AVRational av_div_q(AVRational b, AVRational c)
		{
			return vectors.av_div_q(b, c);
		}

		public unsafe static void av_dump_format(AVFormatContext* ic, int index, string url, int is_output)
		{
			vectors.av_dump_format(ic, index, url, is_output);
		}

		public unsafe static AVDynamicHDRPlus* av_dynamic_hdr_plus_alloc(ulong* size)
		{
			return vectors.av_dynamic_hdr_plus_alloc(size);
		}

		public unsafe static AVDynamicHDRPlus* av_dynamic_hdr_plus_create_side_data(AVFrame* frame)
		{
			return vectors.av_dynamic_hdr_plus_create_side_data(frame);
		}

		public unsafe static int av_dynamic_hdr_plus_from_t35(AVDynamicHDRPlus* s, byte* data, ulong size)
		{
			return vectors.av_dynamic_hdr_plus_from_t35(s, data, size);
		}

		public unsafe static int av_dynamic_hdr_plus_to_t35(AVDynamicHDRPlus* s, byte** data, ulong* size)
		{
			return vectors.av_dynamic_hdr_plus_to_t35(s, data, size);
		}

		public unsafe static void av_dynarray_add(void* tab_ptr, int* nb_ptr, void* elem)
		{
			vectors.av_dynarray_add(tab_ptr, nb_ptr, elem);
		}

		public unsafe static int av_dynarray_add_nofree(void* tab_ptr, int* nb_ptr, void* elem)
		{
			return vectors.av_dynarray_add_nofree(tab_ptr, nb_ptr, elem);
		}

		public unsafe static void* av_dynarray2_add(void** tab_ptr, int* nb_ptr, ulong elem_size, byte* elem_data)
		{
			return vectors.av_dynarray2_add(tab_ptr, nb_ptr, elem_size, elem_data);
		}

		public unsafe static void av_fast_malloc(void* ptr, uint* size, ulong min_size)
		{
			vectors.av_fast_malloc(ptr, size, min_size);
		}

		public unsafe static void av_fast_mallocz(void* ptr, uint* size, ulong min_size)
		{
			vectors.av_fast_mallocz(ptr, size, min_size);
		}

		public unsafe static void av_fast_padded_malloc(void* ptr, uint* size, ulong min_size)
		{
			vectors.av_fast_padded_malloc(ptr, size, min_size);
		}

		public unsafe static void av_fast_padded_mallocz(void* ptr, uint* size, ulong min_size)
		{
			vectors.av_fast_padded_mallocz(ptr, size, min_size);
		}

		public unsafe static void* av_fast_realloc(void* ptr, uint* size, ulong min_size)
		{
			return vectors.av_fast_realloc(ptr, size, min_size);
		}

		public unsafe static int av_file_map(string filename, byte** bufptr, ulong* size, int log_offset, void* log_ctx)
		{
			return vectors.av_file_map(filename, bufptr, size, log_offset, log_ctx);
		}

		public unsafe static void av_file_unmap(byte* bufptr, ulong size)
		{
			vectors.av_file_unmap(bufptr, size);
		}

		public static int av_filename_number_test(string filename)
		{
			return vectors.av_filename_number_test(filename);
		}

		public unsafe static AVFilter* av_filter_iterate(void** opaque)
		{
			return vectors.av_filter_iterate(opaque);
		}

		public unsafe static AVPixelFormat av_find_best_pix_fmt_of_2(AVPixelFormat dst_pix_fmt1, AVPixelFormat dst_pix_fmt2, AVPixelFormat src_pix_fmt, int has_alpha, int* loss_ptr)
		{
			return vectors.av_find_best_pix_fmt_of_2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, has_alpha, loss_ptr);
		}

		public unsafe static int av_find_best_stream(AVFormatContext* ic, AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec** decoder_ret, int flags)
		{
			return vectors.av_find_best_stream(ic, type, wanted_stream_nb, related_stream, decoder_ret, flags);
		}

		public unsafe static int av_find_default_stream_index(AVFormatContext* s)
		{
			return vectors.av_find_default_stream_index(s);
		}

		public unsafe static AVInputFormat* av_find_input_format(string short_name)
		{
			return vectors.av_find_input_format(short_name);
		}

		public unsafe static int av_find_nearest_q_idx(AVRational q, AVRational* q_list)
		{
			return vectors.av_find_nearest_q_idx(q, q_list);
		}

		public unsafe static AVProgram* av_find_program_from_stream(AVFormatContext* ic, AVProgram* last, int s)
		{
			return vectors.av_find_program_from_stream(ic, last, s);
		}

		public static void av_force_cpu_flags(int flags)
		{
			vectors.av_force_cpu_flags(flags);
		}

		public unsafe static byte* av_fourcc_make_string(byte* buf, uint fourcc)
		{
			return vectors.av_fourcc_make_string(buf, fourcc);
		}

		public unsafe static AVFrame* av_frame_alloc()
		{
			return vectors.av_frame_alloc();
		}

		public unsafe static int av_frame_apply_cropping(AVFrame* frame, int flags)
		{
			return vectors.av_frame_apply_cropping(frame, flags);
		}

		public unsafe static AVFrame* av_frame_clone(AVFrame* src)
		{
			return vectors.av_frame_clone(src);
		}

		public unsafe static int av_frame_copy(AVFrame* dst, AVFrame* src)
		{
			return vectors.av_frame_copy(dst, src);
		}

		public unsafe static int av_frame_copy_props(AVFrame* dst, AVFrame* src)
		{
			return vectors.av_frame_copy_props(dst, src);
		}

		public unsafe static void av_frame_free(AVFrame** frame)
		{
			vectors.av_frame_free(frame);
		}

		public unsafe static int av_frame_get_buffer(AVFrame* frame, int align)
		{
			return vectors.av_frame_get_buffer(frame, align);
		}

		public unsafe static AVBufferRef* av_frame_get_plane_buffer(AVFrame* frame, int plane)
		{
			return vectors.av_frame_get_plane_buffer(frame, plane);
		}

		public unsafe static AVFrameSideData* av_frame_get_side_data(AVFrame* frame, AVFrameSideDataType type)
		{
			return vectors.av_frame_get_side_data(frame, type);
		}

		public unsafe static int av_frame_is_writable(AVFrame* frame)
		{
			return vectors.av_frame_is_writable(frame);
		}

		public unsafe static int av_frame_make_writable(AVFrame* frame)
		{
			return vectors.av_frame_make_writable(frame);
		}

		public unsafe static void av_frame_move_ref(AVFrame* dst, AVFrame* src)
		{
			vectors.av_frame_move_ref(dst, src);
		}

		public unsafe static AVFrameSideData* av_frame_new_side_data(AVFrame* frame, AVFrameSideDataType type, ulong size)
		{
			return vectors.av_frame_new_side_data(frame, type, size);
		}

		public unsafe static AVFrameSideData* av_frame_new_side_data_from_buf(AVFrame* frame, AVFrameSideDataType type, AVBufferRef* buf)
		{
			return vectors.av_frame_new_side_data_from_buf(frame, type, buf);
		}

		public unsafe static int av_frame_ref(AVFrame* dst, AVFrame* src)
		{
			return vectors.av_frame_ref(dst, src);
		}

		public unsafe static void av_frame_remove_side_data(AVFrame* frame, AVFrameSideDataType type)
		{
			vectors.av_frame_remove_side_data(frame, type);
		}

		public unsafe static int av_frame_replace(AVFrame* dst, AVFrame* src)
		{
			return vectors.av_frame_replace(dst, src);
		}

		public unsafe static AVFrameSideData* av_frame_side_data_add(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type, AVBufferRef** buf, uint flags)
		{
			return vectors.av_frame_side_data_add(sd, nb_sd, type, buf, flags);
		}

		public unsafe static int av_frame_side_data_clone(AVFrameSideData*** sd, int* nb_sd, AVFrameSideData* src, uint flags)
		{
			return vectors.av_frame_side_data_clone(sd, nb_sd, src, flags);
		}

		public unsafe static AVSideDataDescriptor* av_frame_side_data_desc(AVFrameSideDataType type)
		{
			return vectors.av_frame_side_data_desc(type);
		}

		public unsafe static void av_frame_side_data_free(AVFrameSideData*** sd, int* nb_sd)
		{
			vectors.av_frame_side_data_free(sd, nb_sd);
		}

		public unsafe static AVFrameSideData* av_frame_side_data_get_c(AVFrameSideData** sd, int nb_sd, AVFrameSideDataType type)
		{
			return vectors.av_frame_side_data_get_c(sd, nb_sd, type);
		}

		public static string av_frame_side_data_name(AVFrameSideDataType type)
		{
			return vectors.av_frame_side_data_name(type);
		}

		public unsafe static AVFrameSideData* av_frame_side_data_new(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type, ulong size, uint flags)
		{
			return vectors.av_frame_side_data_new(sd, nb_sd, type, size, flags);
		}

		public unsafe static void av_frame_side_data_remove(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type)
		{
			vectors.av_frame_side_data_remove(sd, nb_sd, type);
		}

		public unsafe static void av_frame_side_data_remove_by_props(AVFrameSideData*** sd, int* nb_sd, int props)
		{
			vectors.av_frame_side_data_remove_by_props(sd, nb_sd, props);
		}

		public unsafe static void av_frame_unref(AVFrame* frame)
		{
			vectors.av_frame_unref(frame);
		}

		public unsafe static void av_free(void* ptr)
		{
			vectors.av_free(ptr);
		}

		public unsafe static void av_freep(void* ptr)
		{
			vectors.av_freep(ptr);
		}

		public static long av_gcd(long a, long b)
		{
			return vectors.av_gcd(a, b);
		}

		public static AVRational av_gcd_q(AVRational a, AVRational b, int max_den, AVRational def)
		{
			return vectors.av_gcd_q(a, b, max_den, def);
		}

		public static AVSampleFormat av_get_alt_sample_fmt(AVSampleFormat sample_fmt, int planar)
		{
			return vectors.av_get_alt_sample_fmt(sample_fmt, planar);
		}

		public unsafe static int av_get_audio_frame_duration(AVCodecContext* avctx, int frame_bytes)
		{
			return vectors.av_get_audio_frame_duration(avctx, frame_bytes);
		}

		public unsafe static int av_get_audio_frame_duration2(AVCodecParameters* par, int frame_bytes)
		{
			return vectors.av_get_audio_frame_duration2(par, frame_bytes);
		}

		public unsafe static int av_get_bits_per_pixel(AVPixFmtDescriptor* pixdesc)
		{
			return vectors.av_get_bits_per_pixel(pixdesc);
		}

		public static int av_get_bits_per_sample(AVCodecID codec_id)
		{
			return vectors.av_get_bits_per_sample(codec_id);
		}

		public static int av_get_bytes_per_sample(AVSampleFormat sample_fmt)
		{
			return vectors.av_get_bytes_per_sample(sample_fmt);
		}

		public static int av_get_cpu_flags()
		{
			return vectors.av_get_cpu_flags();
		}

		public static int av_get_exact_bits_per_sample(AVCodecID codec_id)
		{
			return vectors.av_get_exact_bits_per_sample(codec_id);
		}

		public unsafe static int av_get_frame_filename(byte* buf, int buf_size, string path, int number)
		{
			return vectors.av_get_frame_filename(buf, buf_size, path, number);
		}

		public unsafe static int av_get_frame_filename2(byte* buf, int buf_size, string path, int number, int flags)
		{
			return vectors.av_get_frame_filename2(buf, buf_size, path, number, flags);
		}

		public static string av_get_media_type_string(AVMediaType media_type)
		{
			return vectors.av_get_media_type_string(media_type);
		}

		public unsafe static int av_get_output_timestamp(AVFormatContext* s, int stream, long* dts, long* wall)
		{
			return vectors.av_get_output_timestamp(s, stream, dts, wall);
		}

		public static AVSampleFormat av_get_packed_sample_fmt(AVSampleFormat sample_fmt)
		{
			return vectors.av_get_packed_sample_fmt(sample_fmt);
		}

		public unsafe static int av_get_packet(AVIOContext* s, AVPacket* pkt, int size)
		{
			return vectors.av_get_packet(s, pkt, size);
		}

		public unsafe static int av_get_padded_bits_per_pixel(AVPixFmtDescriptor* pixdesc)
		{
			return vectors.av_get_padded_bits_per_pixel(pixdesc);
		}

		public static AVCodecID av_get_pcm_codec(AVSampleFormat fmt, int be)
		{
			return vectors.av_get_pcm_codec(fmt, be);
		}

		public static byte av_get_picture_type_char(AVPictureType pict_type)
		{
			return vectors.av_get_picture_type_char(pict_type);
		}

		public static AVPixelFormat av_get_pix_fmt(string name)
		{
			return vectors.av_get_pix_fmt(name);
		}

		public static int av_get_pix_fmt_loss(AVPixelFormat dst_pix_fmt, AVPixelFormat src_pix_fmt, int has_alpha)
		{
			return vectors.av_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
		}

		public static string av_get_pix_fmt_name(AVPixelFormat pix_fmt)
		{
			return vectors.av_get_pix_fmt_name(pix_fmt);
		}

		public unsafe static byte* av_get_pix_fmt_string(byte* buf, int buf_size, AVPixelFormat pix_fmt)
		{
			return vectors.av_get_pix_fmt_string(buf, buf_size, pix_fmt);
		}

		public static AVSampleFormat av_get_planar_sample_fmt(AVSampleFormat sample_fmt)
		{
			return vectors.av_get_planar_sample_fmt(sample_fmt);
		}

		public unsafe static string av_get_profile_name(AVCodec* codec, int profile)
		{
			return vectors.av_get_profile_name(codec, profile);
		}

		public static AVSampleFormat av_get_sample_fmt(string name)
		{
			return vectors.av_get_sample_fmt(name);
		}

		public static string av_get_sample_fmt_name(AVSampleFormat sample_fmt)
		{
			return vectors.av_get_sample_fmt_name(sample_fmt);
		}

		public unsafe static byte* av_get_sample_fmt_string(byte* buf, int buf_size, AVSampleFormat sample_fmt)
		{
			return vectors.av_get_sample_fmt_string(buf, buf_size, sample_fmt);
		}

		public static AVRational av_get_time_base_q()
		{
			return vectors.av_get_time_base_q();
		}

		public static long av_gettime()
		{
			return vectors.av_gettime();
		}

		public static long av_gettime_relative()
		{
			return vectors.av_gettime_relative();
		}

		public static int av_gettime_relative_is_monotonic()
		{
			return vectors.av_gettime_relative_is_monotonic();
		}

		public unsafe static int av_grow_packet(AVPacket* pkt, int grow_by)
		{
			return vectors.av_grow_packet(pkt, grow_by);
		}

		public unsafe static AVCodecID av_guess_codec(AVOutputFormat* fmt, string short_name, string filename, string mime_type, AVMediaType type)
		{
			return vectors.av_guess_codec(fmt, short_name, filename, mime_type, type);
		}

		public unsafe static AVOutputFormat* av_guess_format(string short_name, string filename, string mime_type)
		{
			return vectors.av_guess_format(short_name, filename, mime_type);
		}

		public unsafe static AVRational av_guess_frame_rate(AVFormatContext* ctx, AVStream* stream, AVFrame* frame)
		{
			return vectors.av_guess_frame_rate(ctx, stream, frame);
		}

		public unsafe static AVRational av_guess_sample_aspect_ratio(AVFormatContext* format, AVStream* stream, AVFrame* frame)
		{
			return vectors.av_guess_sample_aspect_ratio(format, stream, frame);
		}

		public unsafe static void av_hex_dump(_iobuf* f, byte* buf, int size)
		{
			vectors.av_hex_dump(f, buf, size);
		}

		public unsafe static void av_hex_dump_log(void* avcl, int level, byte* buf, int size)
		{
			vectors.av_hex_dump_log(avcl, level, buf, size);
		}

		public unsafe static AVBufferRef* av_hwdevice_ctx_alloc(AVHWDeviceType type)
		{
			return vectors.av_hwdevice_ctx_alloc(type);
		}

		public unsafe static int av_hwdevice_ctx_create(AVBufferRef** device_ctx, AVHWDeviceType type, string device, AVDictionary* opts, int flags)
		{
			return vectors.av_hwdevice_ctx_create(device_ctx, type, device, opts, flags);
		}

		public unsafe static int av_hwdevice_ctx_create_derived(AVBufferRef** dst_ctx, AVHWDeviceType type, AVBufferRef* src_ctx, int flags)
		{
			return vectors.av_hwdevice_ctx_create_derived(dst_ctx, type, src_ctx, flags);
		}

		public unsafe static int av_hwdevice_ctx_create_derived_opts(AVBufferRef** dst_ctx, AVHWDeviceType type, AVBufferRef* src_ctx, AVDictionary* options, int flags)
		{
			return vectors.av_hwdevice_ctx_create_derived_opts(dst_ctx, type, src_ctx, options, flags);
		}

		public unsafe static int av_hwdevice_ctx_init(AVBufferRef* @ref)
		{
			return vectors.av_hwdevice_ctx_init(@ref);
		}

		public static AVHWDeviceType av_hwdevice_find_type_by_name(string name)
		{
			return vectors.av_hwdevice_find_type_by_name(name);
		}

		public unsafe static AVHWFramesConstraints* av_hwdevice_get_hwframe_constraints(AVBufferRef* @ref, void* hwconfig)
		{
			return vectors.av_hwdevice_get_hwframe_constraints(@ref, hwconfig);
		}

		public static string av_hwdevice_get_type_name(AVHWDeviceType type)
		{
			return vectors.av_hwdevice_get_type_name(type);
		}

		public unsafe static void* av_hwdevice_hwconfig_alloc(AVBufferRef* device_ctx)
		{
			return vectors.av_hwdevice_hwconfig_alloc(device_ctx);
		}

		public static AVHWDeviceType av_hwdevice_iterate_types(AVHWDeviceType prev)
		{
			return vectors.av_hwdevice_iterate_types(prev);
		}

		public unsafe static void av_hwframe_constraints_free(AVHWFramesConstraints** constraints)
		{
			vectors.av_hwframe_constraints_free(constraints);
		}

		public unsafe static AVBufferRef* av_hwframe_ctx_alloc(AVBufferRef* device_ctx)
		{
			return vectors.av_hwframe_ctx_alloc(device_ctx);
		}

		public unsafe static int av_hwframe_ctx_create_derived(AVBufferRef** derived_frame_ctx, AVPixelFormat format, AVBufferRef* derived_device_ctx, AVBufferRef* source_frame_ctx, int flags)
		{
			return vectors.av_hwframe_ctx_create_derived(derived_frame_ctx, format, derived_device_ctx, source_frame_ctx, flags);
		}

		public unsafe static int av_hwframe_ctx_init(AVBufferRef* @ref)
		{
			return vectors.av_hwframe_ctx_init(@ref);
		}

		public unsafe static int av_hwframe_get_buffer(AVBufferRef* hwframe_ctx, AVFrame* frame, int flags)
		{
			return vectors.av_hwframe_get_buffer(hwframe_ctx, frame, flags);
		}

		public unsafe static int av_hwframe_map(AVFrame* dst, AVFrame* src, int flags)
		{
			return vectors.av_hwframe_map(dst, src, flags);
		}

		public unsafe static int av_hwframe_transfer_data(AVFrame* dst, AVFrame* src, int flags)
		{
			return vectors.av_hwframe_transfer_data(dst, src, flags);
		}

		public unsafe static int av_hwframe_transfer_get_formats(AVBufferRef* hwframe_ctx, AVHWFrameTransferDirection dir, AVPixelFormat** formats, int flags)
		{
			return vectors.av_hwframe_transfer_get_formats(hwframe_ctx, dir, formats, flags);
		}

		public static int av_image_alloc(ref byte_ptrArray4 pointers, ref int_array4 linesizes, int w, int h, AVPixelFormat pix_fmt, int align)
		{
			return vectors.av_image_alloc(ref pointers, ref linesizes, w, h, pix_fmt, align);
		}

		public static int av_image_check_sar(uint w, uint h, AVRational sar)
		{
			return vectors.av_image_check_sar(w, h, sar);
		}

		public unsafe static int av_image_check_size(uint w, uint h, int log_offset, void* log_ctx)
		{
			return vectors.av_image_check_size(w, h, log_offset, log_ctx);
		}

		public unsafe static int av_image_check_size2(uint w, uint h, long max_pixels, AVPixelFormat pix_fmt, int log_offset, void* log_ctx)
		{
			return vectors.av_image_check_size2(w, h, max_pixels, pix_fmt, log_offset, log_ctx);
		}

		public static void av_image_copy(ref byte_ptrArray4 dst_data, in int_array4 dst_linesizes, in byte_ptrArray4 src_data, in int_array4 src_linesizes, AVPixelFormat pix_fmt, int width, int height)
		{
			vectors.av_image_copy(ref dst_data, in dst_linesizes, in src_data, in src_linesizes, pix_fmt, width, height);
		}

		public unsafe static void av_image_copy_plane(byte* dst, int dst_linesize, byte* src, int src_linesize, int bytewidth, int height)
		{
			vectors.av_image_copy_plane(dst, dst_linesize, src, src_linesize, bytewidth, height);
		}

		public unsafe static void av_image_copy_plane_uc_from(byte* dst, long dst_linesize, byte* src, long src_linesize, long bytewidth, int height)
		{
			vectors.av_image_copy_plane_uc_from(dst, dst_linesize, src, src_linesize, bytewidth, height);
		}

		public unsafe static int av_image_copy_to_buffer(byte* dst, int dst_size, in byte_ptrArray4 src_data, in int_array4 src_linesize, AVPixelFormat pix_fmt, int width, int height, int align)
		{
			return vectors.av_image_copy_to_buffer(dst, dst_size, in src_data, in src_linesize, pix_fmt, width, height, align);
		}

		public static void av_image_copy_uc_from(ref byte_ptrArray4 dst_data, in long_array4 dst_linesizes, in byte_ptrArray4 src_data, in long_array4 src_linesizes, AVPixelFormat pix_fmt, int width, int height)
		{
			vectors.av_image_copy_uc_from(ref dst_data, in dst_linesizes, in src_data, in src_linesizes, pix_fmt, width, height);
		}

		public unsafe static int av_image_fill_arrays(ref byte_ptrArray4 dst_data, ref int_array4 dst_linesize, byte* src, AVPixelFormat pix_fmt, int width, int height, int align)
		{
			return vectors.av_image_fill_arrays(ref dst_data, ref dst_linesize, src, pix_fmt, width, height, align);
		}

		public static int av_image_fill_black(ref byte_ptrArray4 dst_data, in long_array4 dst_linesize, AVPixelFormat pix_fmt, AVColorRange range, int width, int height)
		{
			return vectors.av_image_fill_black(ref dst_data, in dst_linesize, pix_fmt, range, width, height);
		}

		public static int av_image_fill_color(ref byte_ptrArray4 dst_data, in long_array4 dst_linesize, AVPixelFormat pix_fmt, in uint_array4 color, int width, int height, int flags)
		{
			return vectors.av_image_fill_color(ref dst_data, in dst_linesize, pix_fmt, in color, width, height, flags);
		}

		public static int av_image_fill_linesizes(ref int_array4 linesizes, AVPixelFormat pix_fmt, int width)
		{
			return vectors.av_image_fill_linesizes(ref linesizes, pix_fmt, width);
		}

		public unsafe static void av_image_fill_max_pixsteps(ref int_array4 max_pixsteps, ref int_array4 max_pixstep_comps, AVPixFmtDescriptor* pixdesc)
		{
			vectors.av_image_fill_max_pixsteps(ref max_pixsteps, ref max_pixstep_comps, pixdesc);
		}

		public static int av_image_fill_plane_sizes(ref ulong_array4 size, AVPixelFormat pix_fmt, int height, in long_array4 linesizes)
		{
			return vectors.av_image_fill_plane_sizes(ref size, pix_fmt, height, in linesizes);
		}

		public unsafe static int av_image_fill_pointers(ref byte_ptrArray4 data, AVPixelFormat pix_fmt, int height, byte* ptr, in int_array4 linesizes)
		{
			return vectors.av_image_fill_pointers(ref data, pix_fmt, height, ptr, in linesizes);
		}

		public static int av_image_get_buffer_size(AVPixelFormat pix_fmt, int width, int height, int align)
		{
			return vectors.av_image_get_buffer_size(pix_fmt, width, height, align);
		}

		public static int av_image_get_linesize(AVPixelFormat pix_fmt, int width, int plane)
		{
			return vectors.av_image_get_linesize(pix_fmt, width, plane);
		}

		public unsafe static int av_index_search_timestamp(AVStream* st, long timestamp, int flags)
		{
			return vectors.av_index_search_timestamp(st, timestamp, flags);
		}

		[Obsolete("This function is deprecated. Once it's removed, sizeof(AVPacket) will not be a part of the ABI anymore.")]
		public unsafe static void av_init_packet(AVPacket* pkt)
		{
			vectors.av_init_packet(pkt);
		}

		public unsafe static AVInputFormat* av_input_audio_device_next(AVInputFormat* d)
		{
			return vectors.av_input_audio_device_next(d);
		}

		public unsafe static AVInputFormat* av_input_video_device_next(AVInputFormat* d)
		{
			return vectors.av_input_video_device_next(d);
		}

		[Obsolete]
		public unsafe static uint av_int_list_length_for_size(uint elsize, void* list, ulong term)
		{
			return vectors.av_int_list_length_for_size(elsize, list, term);
		}

		public unsafe static int av_interleaved_write_frame(AVFormatContext* s, AVPacket* pkt)
		{
			return vectors.av_interleaved_write_frame(s, pkt);
		}

		public unsafe static int av_interleaved_write_uncoded_frame(AVFormatContext* s, int stream_index, AVFrame* frame)
		{
			return vectors.av_interleaved_write_uncoded_frame(s, stream_index, frame);
		}

		public unsafe static void av_log(void* avcl, int level, string fmt)
		{
			vectors.av_log(avcl, level, fmt);
		}

		public unsafe static void av_log_default_callback(void* avcl, int level, string fmt, byte* vl)
		{
			vectors.av_log_default_callback(avcl, level, fmt, vl);
		}

		public unsafe static void av_log_format_line(void* ptr, int level, string fmt, byte* vl, byte* line, int line_size, int* print_prefix)
		{
			vectors.av_log_format_line(ptr, level, fmt, vl, line, line_size, print_prefix);
		}

		public unsafe static int av_log_format_line2(void* ptr, int level, string fmt, byte* vl, byte* line, int line_size, int* print_prefix)
		{
			return vectors.av_log_format_line2(ptr, level, fmt, vl, line, line_size, print_prefix);
		}

		public static int av_log_get_flags()
		{
			return vectors.av_log_get_flags();
		}

		public static int av_log_get_level()
		{
			return vectors.av_log_get_level();
		}

		public unsafe static void av_log_once(void* avcl, int initial_level, int subsequent_level, int* state, string fmt)
		{
			vectors.av_log_once(avcl, initial_level, subsequent_level, state, fmt);
		}

		public static void av_log_set_callback(av_log_set_callback_callback_func callback)
		{
			vectors.av_log_set_callback(callback);
		}

		public static void av_log_set_flags(int arg)
		{
			vectors.av_log_set_flags(arg);
		}

		public static void av_log_set_level(int level)
		{
			vectors.av_log_set_level(level);
		}

		public static int av_log2(uint v)
		{
			return vectors.av_log2(v);
		}

		public static int av_log2_16bit(uint v)
		{
			return vectors.av_log2_16bit(v);
		}

		public unsafe static void* av_malloc(ulong size)
		{
			return vectors.av_malloc(size);
		}

		public unsafe static void* av_malloc_array(ulong nmemb, ulong size)
		{
			return vectors.av_malloc_array(nmemb, size);
		}

		public unsafe static void* av_mallocz(ulong size)
		{
			return vectors.av_mallocz(size);
		}

		public unsafe static AVMasteringDisplayMetadata* av_mastering_display_metadata_alloc()
		{
			return vectors.av_mastering_display_metadata_alloc();
		}

		public unsafe static AVMasteringDisplayMetadata* av_mastering_display_metadata_alloc_size(ulong* size)
		{
			return vectors.av_mastering_display_metadata_alloc_size(size);
		}

		public unsafe static AVMasteringDisplayMetadata* av_mastering_display_metadata_create_side_data(AVFrame* frame)
		{
			return vectors.av_mastering_display_metadata_create_side_data(frame);
		}

		public static int av_match_ext(string filename, string extensions)
		{
			return vectors.av_match_ext(filename, extensions);
		}

		public static void av_max_alloc(ulong max)
		{
			vectors.av_max_alloc(max);
		}

		public unsafe static void av_memcpy_backptr(byte* dst, int back, int cnt)
		{
			vectors.av_memcpy_backptr(dst, back, cnt);
		}

		public unsafe static void* av_memdup(void* p, ulong size)
		{
			return vectors.av_memdup(p, size);
		}

		public static AVRational av_mul_q(AVRational b, AVRational c)
		{
			return vectors.av_mul_q(b, c);
		}

		public unsafe static AVOutputFormat* av_muxer_iterate(void** opaque)
		{
			return vectors.av_muxer_iterate(opaque);
		}

		public static int av_nearer_q(AVRational q, AVRational q1, AVRational q2)
		{
			return vectors.av_nearer_q(q, q1, q2);
		}

		public unsafe static int av_new_packet(AVPacket* pkt, int size)
		{
			return vectors.av_new_packet(pkt, size);
		}

		public unsafe static AVProgram* av_new_program(AVFormatContext* s, int id)
		{
			return vectors.av_new_program(s, id);
		}

		public unsafe static AVClass* av_opt_child_class_iterate(AVClass* parent, void** iter)
		{
			return vectors.av_opt_child_class_iterate(parent, iter);
		}

		public unsafe static void* av_opt_child_next(void* obj, void* prev)
		{
			return vectors.av_opt_child_next(obj, prev);
		}

		public unsafe static int av_opt_copy(void* dest, void* src)
		{
			return vectors.av_opt_copy(dest, src);
		}

		public unsafe static int av_opt_eval_double(void* obj, AVOption* o, string val, double* double_out)
		{
			return vectors.av_opt_eval_double(obj, o, val, double_out);
		}

		public unsafe static int av_opt_eval_flags(void* obj, AVOption* o, string val, int* flags_out)
		{
			return vectors.av_opt_eval_flags(obj, o, val, flags_out);
		}

		public unsafe static int av_opt_eval_float(void* obj, AVOption* o, string val, float* float_out)
		{
			return vectors.av_opt_eval_float(obj, o, val, float_out);
		}

		public unsafe static int av_opt_eval_int(void* obj, AVOption* o, string val, int* int_out)
		{
			return vectors.av_opt_eval_int(obj, o, val, int_out);
		}

		public unsafe static int av_opt_eval_int64(void* obj, AVOption* o, string val, long* int64_out)
		{
			return vectors.av_opt_eval_int64(obj, o, val, int64_out);
		}

		public unsafe static int av_opt_eval_q(void* obj, AVOption* o, string val, AVRational* q_out)
		{
			return vectors.av_opt_eval_q(obj, o, val, q_out);
		}

		public unsafe static int av_opt_eval_uint(void* obj, AVOption* o, string val, uint* uint_out)
		{
			return vectors.av_opt_eval_uint(obj, o, val, uint_out);
		}

		public unsafe static AVOption* av_opt_find(void* obj, string name, string unit, int opt_flags, int search_flags)
		{
			return vectors.av_opt_find(obj, name, unit, opt_flags, search_flags);
		}

		public unsafe static AVOption* av_opt_find2(void* obj, string name, string unit, int opt_flags, int search_flags, void** target_obj)
		{
			return vectors.av_opt_find2(obj, name, unit, opt_flags, search_flags, target_obj);
		}

		public unsafe static int av_opt_flag_is_set(void* obj, string field_name, string flag_name)
		{
			return vectors.av_opt_flag_is_set(obj, field_name, flag_name);
		}

		public unsafe static void av_opt_free(void* obj)
		{
			vectors.av_opt_free(obj);
		}

		public unsafe static void av_opt_freep_ranges(AVOptionRanges** ranges)
		{
			vectors.av_opt_freep_ranges(ranges);
		}

		public unsafe static int av_opt_get(void* obj, string name, int search_flags, byte** out_val)
		{
			return vectors.av_opt_get(obj, name, search_flags, out_val);
		}

		public unsafe static int av_opt_get_array(void* obj, string name, int search_flags, uint start_elem, uint nb_elems, AVOptionType out_type, void* out_val)
		{
			return vectors.av_opt_get_array(obj, name, search_flags, start_elem, nb_elems, out_type, out_val);
		}

		public unsafe static int av_opt_get_array_size(void* obj, string name, int search_flags, uint* out_val)
		{
			return vectors.av_opt_get_array_size(obj, name, search_flags, out_val);
		}

		public unsafe static int av_opt_get_chlayout(void* obj, string name, int search_flags, AVChannelLayout* layout)
		{
			return vectors.av_opt_get_chlayout(obj, name, search_flags, layout);
		}

		public unsafe static int av_opt_get_dict_val(void* obj, string name, int search_flags, AVDictionary** out_val)
		{
			return vectors.av_opt_get_dict_val(obj, name, search_flags, out_val);
		}

		public unsafe static int av_opt_get_double(void* obj, string name, int search_flags, double* out_val)
		{
			return vectors.av_opt_get_double(obj, name, search_flags, out_val);
		}

		public unsafe static int av_opt_get_image_size(void* obj, string name, int search_flags, int* w_out, int* h_out)
		{
			return vectors.av_opt_get_image_size(obj, name, search_flags, w_out, h_out);
		}

		public unsafe static int av_opt_get_int(void* obj, string name, int search_flags, long* out_val)
		{
			return vectors.av_opt_get_int(obj, name, search_flags, out_val);
		}

		public unsafe static int av_opt_get_key_value(byte** ropts, string key_val_sep, string pairs_sep, uint flags, byte** rkey, byte** rval)
		{
			return vectors.av_opt_get_key_value(ropts, key_val_sep, pairs_sep, flags, rkey, rval);
		}

		public unsafe static int av_opt_get_pixel_fmt(void* obj, string name, int search_flags, AVPixelFormat* out_fmt)
		{
			return vectors.av_opt_get_pixel_fmt(obj, name, search_flags, out_fmt);
		}

		public unsafe static int av_opt_get_q(void* obj, string name, int search_flags, AVRational* out_val)
		{
			return vectors.av_opt_get_q(obj, name, search_flags, out_val);
		}

		public unsafe static int av_opt_get_sample_fmt(void* obj, string name, int search_flags, AVSampleFormat* out_fmt)
		{
			return vectors.av_opt_get_sample_fmt(obj, name, search_flags, out_fmt);
		}

		public unsafe static int av_opt_get_video_rate(void* obj, string name, int search_flags, AVRational* out_val)
		{
			return vectors.av_opt_get_video_rate(obj, name, search_flags, out_val);
		}

		public unsafe static int av_opt_is_set_to_default(void* obj, AVOption* o)
		{
			return vectors.av_opt_is_set_to_default(obj, o);
		}

		public unsafe static int av_opt_is_set_to_default_by_name(void* obj, string name, int search_flags)
		{
			return vectors.av_opt_is_set_to_default_by_name(obj, name, search_flags);
		}

		public unsafe static AVOption* av_opt_next(void* obj, AVOption* prev)
		{
			return vectors.av_opt_next(obj, prev);
		}

		[Obsolete("direct access to AVOption-exported fields is not supported")]
		public unsafe static void* av_opt_ptr(AVClass* avclass, void* obj, string name)
		{
			return vectors.av_opt_ptr(avclass, obj, name);
		}

		public unsafe static int av_opt_query_ranges(AVOptionRanges** p0, void* obj, string key, int flags)
		{
			return vectors.av_opt_query_ranges(p0, obj, key, flags);
		}

		public unsafe static int av_opt_query_ranges_default(AVOptionRanges** p0, void* obj, string key, int flags)
		{
			return vectors.av_opt_query_ranges_default(p0, obj, key, flags);
		}

		public unsafe static int av_opt_serialize(void* obj, int opt_flags, int flags, byte** buffer, byte key_val_sep, byte pairs_sep)
		{
			return vectors.av_opt_serialize(obj, opt_flags, flags, buffer, key_val_sep, pairs_sep);
		}

		public unsafe static int av_opt_set(void* obj, string name, string val, int search_flags)
		{
			return vectors.av_opt_set(obj, name, val, search_flags);
		}

		public unsafe static int av_opt_set_array(void* obj, string name, int search_flags, uint start_elem, uint nb_elems, AVOptionType val_type, void* val)
		{
			return vectors.av_opt_set_array(obj, name, search_flags, start_elem, nb_elems, val_type, val);
		}

		public unsafe static int av_opt_set_bin(void* obj, string name, byte* val, int size, int search_flags)
		{
			return vectors.av_opt_set_bin(obj, name, val, size, search_flags);
		}

		public unsafe static int av_opt_set_chlayout(void* obj, string name, AVChannelLayout* layout, int search_flags)
		{
			return vectors.av_opt_set_chlayout(obj, name, layout, search_flags);
		}

		public unsafe static void av_opt_set_defaults(void* s)
		{
			vectors.av_opt_set_defaults(s);
		}

		public unsafe static void av_opt_set_defaults2(void* s, int mask, int flags)
		{
			vectors.av_opt_set_defaults2(s, mask, flags);
		}

		public unsafe static int av_opt_set_dict(void* obj, AVDictionary** options)
		{
			return vectors.av_opt_set_dict(obj, options);
		}

		public unsafe static int av_opt_set_dict_val(void* obj, string name, AVDictionary* val, int search_flags)
		{
			return vectors.av_opt_set_dict_val(obj, name, val, search_flags);
		}

		public unsafe static int av_opt_set_dict2(void* obj, AVDictionary** options, int search_flags)
		{
			return vectors.av_opt_set_dict2(obj, options, search_flags);
		}

		public unsafe static int av_opt_set_double(void* obj, string name, double val, int search_flags)
		{
			return vectors.av_opt_set_double(obj, name, val, search_flags);
		}

		public unsafe static int av_opt_set_from_string(void* ctx, string opts, byte** shorthand, string key_val_sep, string pairs_sep)
		{
			return vectors.av_opt_set_from_string(ctx, opts, shorthand, key_val_sep, pairs_sep);
		}

		public unsafe static int av_opt_set_image_size(void* obj, string name, int w, int h, int search_flags)
		{
			return vectors.av_opt_set_image_size(obj, name, w, h, search_flags);
		}

		public unsafe static int av_opt_set_int(void* obj, string name, long val, int search_flags)
		{
			return vectors.av_opt_set_int(obj, name, val, search_flags);
		}

		public unsafe static int av_opt_set_pixel_fmt(void* obj, string name, AVPixelFormat fmt, int search_flags)
		{
			return vectors.av_opt_set_pixel_fmt(obj, name, fmt, search_flags);
		}

		public unsafe static int av_opt_set_q(void* obj, string name, AVRational val, int search_flags)
		{
			return vectors.av_opt_set_q(obj, name, val, search_flags);
		}

		public unsafe static int av_opt_set_sample_fmt(void* obj, string name, AVSampleFormat fmt, int search_flags)
		{
			return vectors.av_opt_set_sample_fmt(obj, name, fmt, search_flags);
		}

		public unsafe static int av_opt_set_video_rate(void* obj, string name, AVRational val, int search_flags)
		{
			return vectors.av_opt_set_video_rate(obj, name, val, search_flags);
		}

		public unsafe static int av_opt_show2(void* obj, void* av_log_obj, int req_flags, int rej_flags)
		{
			return vectors.av_opt_show2(obj, av_log_obj, req_flags, rej_flags);
		}

		public unsafe static AVOutputFormat* av_output_audio_device_next(AVOutputFormat* d)
		{
			return vectors.av_output_audio_device_next(d);
		}

		public unsafe static AVOutputFormat* av_output_video_device_next(AVOutputFormat* d)
		{
			return vectors.av_output_video_device_next(d);
		}

		public unsafe static int av_packet_add_side_data(AVPacket* pkt, AVPacketSideDataType type, byte* data, ulong size)
		{
			return vectors.av_packet_add_side_data(pkt, type, data, size);
		}

		public unsafe static AVPacket* av_packet_alloc()
		{
			return vectors.av_packet_alloc();
		}

		public unsafe static AVPacket* av_packet_clone(AVPacket* src)
		{
			return vectors.av_packet_clone(src);
		}

		public unsafe static int av_packet_copy_props(AVPacket* dst, AVPacket* src)
		{
			return vectors.av_packet_copy_props(dst, src);
		}

		public unsafe static void av_packet_free(AVPacket** pkt)
		{
			vectors.av_packet_free(pkt);
		}

		public unsafe static void av_packet_free_side_data(AVPacket* pkt)
		{
			vectors.av_packet_free_side_data(pkt);
		}

		public unsafe static int av_packet_from_data(AVPacket* pkt, byte* data, int size)
		{
			return vectors.av_packet_from_data(pkt, data, size);
		}

		public unsafe static byte* av_packet_get_side_data(AVPacket* pkt, AVPacketSideDataType type, ulong* size)
		{
			return vectors.av_packet_get_side_data(pkt, type, size);
		}

		public unsafe static int av_packet_make_refcounted(AVPacket* pkt)
		{
			return vectors.av_packet_make_refcounted(pkt);
		}

		public unsafe static int av_packet_make_writable(AVPacket* pkt)
		{
			return vectors.av_packet_make_writable(pkt);
		}

		public unsafe static void av_packet_move_ref(AVPacket* dst, AVPacket* src)
		{
			vectors.av_packet_move_ref(dst, src);
		}

		public unsafe static byte* av_packet_new_side_data(AVPacket* pkt, AVPacketSideDataType type, ulong size)
		{
			return vectors.av_packet_new_side_data(pkt, type, size);
		}

		public unsafe static byte* av_packet_pack_dictionary(AVDictionary* dict, ulong* size)
		{
			return vectors.av_packet_pack_dictionary(dict, size);
		}

		public unsafe static int av_packet_ref(AVPacket* dst, AVPacket* src)
		{
			return vectors.av_packet_ref(dst, src);
		}

		public unsafe static void av_packet_rescale_ts(AVPacket* pkt, AVRational tb_src, AVRational tb_dst)
		{
			vectors.av_packet_rescale_ts(pkt, tb_src, tb_dst);
		}

		public unsafe static int av_packet_shrink_side_data(AVPacket* pkt, AVPacketSideDataType type, ulong size)
		{
			return vectors.av_packet_shrink_side_data(pkt, type, size);
		}

		public unsafe static AVPacketSideData* av_packet_side_data_add(AVPacketSideData** sd, int* nb_sd, AVPacketSideDataType type, void* data, ulong size, int flags)
		{
			return vectors.av_packet_side_data_add(sd, nb_sd, type, data, size, flags);
		}

		public unsafe static void av_packet_side_data_free(AVPacketSideData** sd, int* nb_sd)
		{
			vectors.av_packet_side_data_free(sd, nb_sd);
		}

		public unsafe static AVPacketSideData* av_packet_side_data_get(AVPacketSideData* sd, int nb_sd, AVPacketSideDataType type)
		{
			return vectors.av_packet_side_data_get(sd, nb_sd, type);
		}

		public static string av_packet_side_data_name(AVPacketSideDataType type)
		{
			return vectors.av_packet_side_data_name(type);
		}

		public unsafe static AVPacketSideData* av_packet_side_data_new(AVPacketSideData** psd, int* pnb_sd, AVPacketSideDataType type, ulong size, int flags)
		{
			return vectors.av_packet_side_data_new(psd, pnb_sd, type, size, flags);
		}

		public unsafe static void av_packet_side_data_remove(AVPacketSideData* sd, int* nb_sd, AVPacketSideDataType type)
		{
			vectors.av_packet_side_data_remove(sd, nb_sd, type);
		}

		public unsafe static int av_packet_unpack_dictionary(byte* data, ulong size, AVDictionary** dict)
		{
			return vectors.av_packet_unpack_dictionary(data, size, dict);
		}

		public unsafe static void av_packet_unref(AVPacket* pkt)
		{
			vectors.av_packet_unref(pkt);
		}

		public unsafe static int av_parse_cpu_caps(uint* flags, string s)
		{
			return vectors.av_parse_cpu_caps(flags, s);
		}

		public unsafe static void av_parser_close(AVCodecParserContext* s)
		{
			vectors.av_parser_close(s);
		}

		public unsafe static AVCodecParserContext* av_parser_init(int codec_id)
		{
			return vectors.av_parser_init(codec_id);
		}

		public unsafe static AVCodecParser* av_parser_iterate(void** opaque)
		{
			return vectors.av_parser_iterate(opaque);
		}

		public unsafe static int av_parser_parse2(AVCodecParserContext* s, AVCodecContext* avctx, byte** poutbuf, int* poutbuf_size, byte* buf, int buf_size, long pts, long dts, long pos)
		{
			return vectors.av_parser_parse2(s, avctx, poutbuf, poutbuf_size, buf, buf_size, pts, dts, pos);
		}

		public static int av_pix_fmt_count_planes(AVPixelFormat pix_fmt)
		{
			return vectors.av_pix_fmt_count_planes(pix_fmt);
		}

		public unsafe static AVPixFmtDescriptor* av_pix_fmt_desc_get(AVPixelFormat pix_fmt)
		{
			return vectors.av_pix_fmt_desc_get(pix_fmt);
		}

		public unsafe static AVPixelFormat av_pix_fmt_desc_get_id(AVPixFmtDescriptor* desc)
		{
			return vectors.av_pix_fmt_desc_get_id(desc);
		}

		public unsafe static AVPixFmtDescriptor* av_pix_fmt_desc_next(AVPixFmtDescriptor* prev)
		{
			return vectors.av_pix_fmt_desc_next(prev);
		}

		public unsafe static int av_pix_fmt_get_chroma_sub_sample(AVPixelFormat pix_fmt, int* h_shift, int* v_shift)
		{
			return vectors.av_pix_fmt_get_chroma_sub_sample(pix_fmt, h_shift, v_shift);
		}

		public static AVPixelFormat av_pix_fmt_swap_endianness(AVPixelFormat pix_fmt)
		{
			return vectors.av_pix_fmt_swap_endianness(pix_fmt);
		}

		public unsafe static void av_pkt_dump_log2(void* avcl, int level, AVPacket* pkt, int dump_payload, AVStream* st)
		{
			vectors.av_pkt_dump_log2(avcl, level, pkt, dump_payload, st);
		}

		public unsafe static void av_pkt_dump2(_iobuf* f, AVPacket* pkt, int dump_payload, AVStream* st)
		{
			vectors.av_pkt_dump2(f, pkt, dump_payload, st);
		}

		public unsafe static int av_probe_input_buffer(AVIOContext* pb, AVInputFormat** fmt, string url, void* logctx, uint offset, uint max_probe_size)
		{
			return vectors.av_probe_input_buffer(pb, fmt, url, logctx, offset, max_probe_size);
		}

		public unsafe static int av_probe_input_buffer2(AVIOContext* pb, AVInputFormat** fmt, string url, void* logctx, uint offset, uint max_probe_size)
		{
			return vectors.av_probe_input_buffer2(pb, fmt, url, logctx, offset, max_probe_size);
		}

		public unsafe static AVInputFormat* av_probe_input_format(AVProbeData* pd, int is_opened)
		{
			return vectors.av_probe_input_format(pd, is_opened);
		}

		public unsafe static AVInputFormat* av_probe_input_format2(AVProbeData* pd, int is_opened, int* score_max)
		{
			return vectors.av_probe_input_format2(pd, is_opened, score_max);
		}

		public unsafe static AVInputFormat* av_probe_input_format3(AVProbeData* pd, int is_opened, int* score_ret)
		{
			return vectors.av_probe_input_format3(pd, is_opened, score_ret);
		}

		public unsafe static void av_program_add_stream_index(AVFormatContext* ac, int progid, uint idx)
		{
			vectors.av_program_add_stream_index(ac, progid, idx);
		}

		public static uint av_q2intfloat(AVRational q)
		{
			return vectors.av_q2intfloat(q);
		}

		public unsafe static int av_read_frame(AVFormatContext* s, AVPacket* pkt)
		{
			return vectors.av_read_frame(s, pkt);
		}

		public unsafe static void av_read_image_line(ushort* dst, in byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int read_pal_component)
		{
			vectors.av_read_image_line(dst, in data, in linesize, desc, x, y, c, w, read_pal_component);
		}

		public unsafe static void av_read_image_line2(void* dst, in byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int read_pal_component, int dst_element_size)
		{
			vectors.av_read_image_line2(dst, in data, in linesize, desc, x, y, c, w, read_pal_component, dst_element_size);
		}

		public unsafe static int av_read_pause(AVFormatContext* s)
		{
			return vectors.av_read_pause(s);
		}

		public unsafe static int av_read_play(AVFormatContext* s)
		{
			return vectors.av_read_play(s);
		}

		public unsafe static void* av_realloc(void* ptr, ulong size)
		{
			return vectors.av_realloc(ptr, size);
		}

		public unsafe static void* av_realloc_array(void* ptr, ulong nmemb, ulong size)
		{
			return vectors.av_realloc_array(ptr, nmemb, size);
		}

		public unsafe static void* av_realloc_f(void* ptr, ulong nelem, ulong elsize)
		{
			return vectors.av_realloc_f(ptr, nelem, elsize);
		}

		public unsafe static int av_reallocp(void* ptr, ulong size)
		{
			return vectors.av_reallocp(ptr, size);
		}

		public unsafe static int av_reallocp_array(void* ptr, ulong nmemb, ulong size)
		{
			return vectors.av_reallocp_array(ptr, nmemb, size);
		}

		public unsafe static int av_reduce(int* dst_num, int* dst_den, long num, long den, long max)
		{
			return vectors.av_reduce(dst_num, dst_den, num, den, max);
		}

		public static long av_rescale(long a, long b, long c)
		{
			return vectors.av_rescale(a, b, c);
		}

		public unsafe static long av_rescale_delta(AVRational in_tb, long in_ts, AVRational fs_tb, int duration, long* last, AVRational out_tb)
		{
			return vectors.av_rescale_delta(in_tb, in_ts, fs_tb, duration, last, out_tb);
		}

		public static long av_rescale_q(long a, AVRational bq, AVRational cq)
		{
			return vectors.av_rescale_q(a, bq, cq);
		}

		public static long av_rescale_q_rnd(long a, AVRational bq, AVRational cq, AVRounding rnd)
		{
			return vectors.av_rescale_q_rnd(a, bq, cq, rnd);
		}

		public static long av_rescale_rnd(long a, long b, long c, AVRounding rnd)
		{
			return vectors.av_rescale_rnd(a, b, c, rnd);
		}

		public static int av_sample_fmt_is_planar(AVSampleFormat sample_fmt)
		{
			return vectors.av_sample_fmt_is_planar(sample_fmt);
		}

		public unsafe static int av_samples_alloc(byte** audio_data, int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)
		{
			return vectors.av_samples_alloc(audio_data, linesize, nb_channels, nb_samples, sample_fmt, align);
		}

		public unsafe static int av_samples_alloc_array_and_samples(byte*** audio_data, int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)
		{
			return vectors.av_samples_alloc_array_and_samples(audio_data, linesize, nb_channels, nb_samples, sample_fmt, align);
		}

		public unsafe static int av_samples_copy(byte** dst, byte** src, int dst_offset, int src_offset, int nb_samples, int nb_channels, AVSampleFormat sample_fmt)
		{
			return vectors.av_samples_copy(dst, src, dst_offset, src_offset, nb_samples, nb_channels, sample_fmt);
		}

		public unsafe static int av_samples_fill_arrays(byte** audio_data, int* linesize, byte* buf, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)
		{
			return vectors.av_samples_fill_arrays(audio_data, linesize, buf, nb_channels, nb_samples, sample_fmt, align);
		}

		public unsafe static int av_samples_get_buffer_size(int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)
		{
			return vectors.av_samples_get_buffer_size(linesize, nb_channels, nb_samples, sample_fmt, align);
		}

		public unsafe static int av_samples_set_silence(byte** audio_data, int offset, int nb_samples, int nb_channels, AVSampleFormat sample_fmt)
		{
			return vectors.av_samples_set_silence(audio_data, offset, nb_samples, nb_channels, sample_fmt);
		}

		public unsafe static int av_sdp_create(AVFormatContext** ac, int n_files, byte* buf, int size)
		{
			return vectors.av_sdp_create(ac, n_files, buf, size);
		}

		public unsafe static int av_seek_frame(AVFormatContext* s, int stream_index, long timestamp, int flags)
		{
			return vectors.av_seek_frame(s, stream_index, timestamp, flags);
		}

		public unsafe static int av_set_options_string(void* ctx, string opts, string key_val_sep, string pairs_sep)
		{
			return vectors.av_set_options_string(ctx, opts, key_val_sep, pairs_sep);
		}

		public unsafe static void av_shrink_packet(AVPacket* pkt, int size)
		{
			vectors.av_shrink_packet(pkt, size);
		}

		public unsafe static int av_size_mult(ulong a, ulong b, ulong* r)
		{
			return vectors.av_size_mult(a, b, r);
		}

		public unsafe static byte* av_strdup(string s)
		{
			return vectors.av_strdup(s);
		}

		public unsafe static AVClass* av_stream_get_class()
		{
			return vectors.av_stream_get_class();
		}

		[Obsolete("do not call this function")]
		public unsafe static AVRational av_stream_get_codec_timebase(AVStream* st)
		{
			return vectors.av_stream_get_codec_timebase(st);
		}

		public unsafe static AVCodecParserContext* av_stream_get_parser(AVStream* s)
		{
			return vectors.av_stream_get_parser(s);
		}

		public unsafe static AVClass* av_stream_group_get_class()
		{
			return vectors.av_stream_group_get_class();
		}

		public unsafe static int av_strerror(int errnum, byte* errbuf, ulong errbuf_size)
		{
			return vectors.av_strerror(errnum, errbuf, errbuf_size);
		}

		public unsafe static byte* av_strndup(string s, ulong len)
		{
			return vectors.av_strndup(s, len);
		}

		public static AVRational av_sub_q(AVRational b, AVRational c)
		{
			return vectors.av_sub_q(b, c);
		}

		public static int av_timecode_adjust_ntsc_framenum2(int framenum, int fps)
		{
			return vectors.av_timecode_adjust_ntsc_framenum2(framenum, fps);
		}

		public static int av_timecode_check_frame_rate(AVRational rate)
		{
			return vectors.av_timecode_check_frame_rate(rate);
		}

		public static uint av_timecode_get_smpte(AVRational rate, int drop, int hh, int mm, int ss, int ff)
		{
			return vectors.av_timecode_get_smpte(rate, drop, hh, mm, ss, ff);
		}

		public unsafe static uint av_timecode_get_smpte_from_framenum(AVTimecode* tc, int framenum)
		{
			return vectors.av_timecode_get_smpte_from_framenum(tc, framenum);
		}

		public unsafe static int av_timecode_init(AVTimecode* tc, AVRational rate, int flags, int frame_start, void* log_ctx)
		{
			return vectors.av_timecode_init(tc, rate, flags, frame_start, log_ctx);
		}

		public unsafe static int av_timecode_init_from_components(AVTimecode* tc, AVRational rate, int flags, int hh, int mm, int ss, int ff, void* log_ctx)
		{
			return vectors.av_timecode_init_from_components(tc, rate, flags, hh, mm, ss, ff, log_ctx);
		}

		public unsafe static int av_timecode_init_from_string(AVTimecode* tc, AVRational rate, string str, void* log_ctx)
		{
			return vectors.av_timecode_init_from_string(tc, rate, str, log_ctx);
		}

		public unsafe static byte* av_timecode_make_mpeg_tc_string(byte* buf, uint tc25bit)
		{
			return vectors.av_timecode_make_mpeg_tc_string(buf, tc25bit);
		}

		public unsafe static byte* av_timecode_make_smpte_tc_string(byte* buf, uint tcsmpte, int prevent_df)
		{
			return vectors.av_timecode_make_smpte_tc_string(buf, tcsmpte, prevent_df);
		}

		public unsafe static byte* av_timecode_make_smpte_tc_string2(byte* buf, AVRational rate, uint tcsmpte, int prevent_df, int skip_field)
		{
			return vectors.av_timecode_make_smpte_tc_string2(buf, rate, tcsmpte, prevent_df, skip_field);
		}

		public unsafe static byte* av_timecode_make_string(AVTimecode* tc, byte* buf, int framenum)
		{
			return vectors.av_timecode_make_string(tc, buf, framenum);
		}

		public unsafe static void av_tree_destroy(AVTreeNode* t)
		{
			vectors.av_tree_destroy(t);
		}

		public unsafe static void av_tree_enumerate(AVTreeNode* t, void* opaque, av_tree_enumerate_cmp_func cmp, av_tree_enumerate_enu_func enu)
		{
			vectors.av_tree_enumerate(t, opaque, cmp, enu);
		}

		public unsafe static void* av_tree_find(AVTreeNode* root, void* key, av_tree_find_cmp_func cmp, ref void_ptrArray2 next)
		{
			return vectors.av_tree_find(root, key, cmp, ref next);
		}

		public unsafe static void* av_tree_insert(AVTreeNode** rootp, void* key, av_tree_insert_cmp_func cmp, AVTreeNode** next)
		{
			return vectors.av_tree_insert(rootp, key, cmp, next);
		}

		public unsafe static AVTreeNode* av_tree_node_alloc()
		{
			return vectors.av_tree_node_alloc();
		}

		public unsafe static void av_url_split(byte* proto, int proto_size, byte* authorization, int authorization_size, byte* hostname, int hostname_size, int* port_ptr, byte* path, int path_size, string url)
		{
			vectors.av_url_split(proto, proto_size, authorization, authorization_size, hostname, hostname_size, port_ptr, path, path_size, url);
		}

		public static int av_usleep(uint usec)
		{
			return vectors.av_usleep(usec);
		}

		public static string av_version_info()
		{
			return vectors.av_version_info();
		}

		public unsafe static void av_vlog(void* avcl, int level, string fmt, byte* vl)
		{
			vectors.av_vlog(avcl, level, fmt, vl);
		}

		public unsafe static int av_write_frame(AVFormatContext* s, AVPacket* pkt)
		{
			return vectors.av_write_frame(s, pkt);
		}

		public unsafe static void av_write_image_line(ushort* src, ref byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w)
		{
			vectors.av_write_image_line(src, ref data, in linesize, desc, x, y, c, w);
		}

		public unsafe static void av_write_image_line2(void* src, ref byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int src_element_size)
		{
			vectors.av_write_image_line2(src, ref data, in linesize, desc, x, y, c, w, src_element_size);
		}

		public unsafe static int av_write_trailer(AVFormatContext* s)
		{
			return vectors.av_write_trailer(s);
		}

		public unsafe static int av_write_uncoded_frame(AVFormatContext* s, int stream_index, AVFrame* frame)
		{
			return vectors.av_write_uncoded_frame(s, stream_index, frame);
		}

		public unsafe static int av_write_uncoded_frame_query(AVFormatContext* s, int stream_index)
		{
			return vectors.av_write_uncoded_frame_query(s, stream_index);
		}

		public unsafe static uint av_xiphlacing(byte* s, uint v)
		{
			return vectors.av_xiphlacing(s, v);
		}

		public unsafe static void avcodec_align_dimensions(AVCodecContext* s, int* width, int* height)
		{
			vectors.avcodec_align_dimensions(s, width, height);
		}

		public unsafe static void avcodec_align_dimensions2(AVCodecContext* s, int* width, int* height, ref int_array8 linesize_align)
		{
			vectors.avcodec_align_dimensions2(s, width, height, ref linesize_align);
		}

		public unsafe static AVCodecContext* avcodec_alloc_context3(AVCodec* codec)
		{
			return vectors.avcodec_alloc_context3(codec);
		}

		public static string avcodec_configuration()
		{
			return vectors.avcodec_configuration();
		}

		public unsafe static int avcodec_decode_subtitle2(AVCodecContext* avctx, AVSubtitle* sub, int* got_sub_ptr, AVPacket* avpkt)
		{
			return vectors.avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, avpkt);
		}

		public unsafe static int avcodec_default_execute(AVCodecContext* c, avcodec_default_execute_func_func func, void* arg, int* ret, int count, int size)
		{
			return vectors.avcodec_default_execute(c, func, arg, ret, count, size);
		}

		public unsafe static int avcodec_default_execute2(AVCodecContext* c, avcodec_default_execute2_func_func func, void* arg, int* ret, int count)
		{
			return vectors.avcodec_default_execute2(c, func, arg, ret, count);
		}

		public unsafe static int avcodec_default_get_buffer2(AVCodecContext* s, AVFrame* frame, int flags)
		{
			return vectors.avcodec_default_get_buffer2(s, frame, flags);
		}

		public unsafe static int avcodec_default_get_encode_buffer(AVCodecContext* s, AVPacket* pkt, int flags)
		{
			return vectors.avcodec_default_get_encode_buffer(s, pkt, flags);
		}

		public unsafe static AVPixelFormat avcodec_default_get_format(AVCodecContext* s, AVPixelFormat* fmt)
		{
			return vectors.avcodec_default_get_format(s, fmt);
		}

		public unsafe static AVCodecDescriptor* avcodec_descriptor_get(AVCodecID id)
		{
			return vectors.avcodec_descriptor_get(id);
		}

		public unsafe static AVCodecDescriptor* avcodec_descriptor_get_by_name(string name)
		{
			return vectors.avcodec_descriptor_get_by_name(name);
		}

		public unsafe static AVCodecDescriptor* avcodec_descriptor_next(AVCodecDescriptor* prev)
		{
			return vectors.avcodec_descriptor_next(prev);
		}

		public unsafe static int avcodec_encode_subtitle(AVCodecContext* avctx, byte* buf, int buf_size, AVSubtitle* sub)
		{
			return vectors.avcodec_encode_subtitle(avctx, buf, buf_size, sub);
		}

		public unsafe static int avcodec_fill_audio_frame(AVFrame* frame, int nb_channels, AVSampleFormat sample_fmt, byte* buf, int buf_size, int align)
		{
			return vectors.avcodec_fill_audio_frame(frame, nb_channels, sample_fmt, buf, buf_size, align);
		}

		public unsafe static AVPixelFormat avcodec_find_best_pix_fmt_of_list(AVPixelFormat* pix_fmt_list, AVPixelFormat src_pix_fmt, int has_alpha, int* loss_ptr)
		{
			return vectors.avcodec_find_best_pix_fmt_of_list(pix_fmt_list, src_pix_fmt, has_alpha, loss_ptr);
		}

		public unsafe static AVCodec* avcodec_find_decoder(AVCodecID id)
		{
			return vectors.avcodec_find_decoder(id);
		}

		public unsafe static AVCodec* avcodec_find_decoder_by_name(string name)
		{
			return vectors.avcodec_find_decoder_by_name(name);
		}

		public unsafe static AVCodec* avcodec_find_encoder(AVCodecID id)
		{
			return vectors.avcodec_find_encoder(id);
		}

		public unsafe static AVCodec* avcodec_find_encoder_by_name(string name)
		{
			return vectors.avcodec_find_encoder_by_name(name);
		}

		public unsafe static void avcodec_flush_buffers(AVCodecContext* avctx)
		{
			vectors.avcodec_flush_buffers(avctx);
		}

		public unsafe static void avcodec_free_context(AVCodecContext** avctx)
		{
			vectors.avcodec_free_context(avctx);
		}

		public unsafe static AVClass* avcodec_get_class()
		{
			return vectors.avcodec_get_class();
		}

		public unsafe static AVCodecHWConfig* avcodec_get_hw_config(AVCodec* codec, int index)
		{
			return vectors.avcodec_get_hw_config(codec, index);
		}

		public unsafe static int avcodec_get_hw_frames_parameters(AVCodecContext* avctx, AVBufferRef* device_ref, AVPixelFormat hw_pix_fmt, AVBufferRef** out_frames_ref)
		{
			return vectors.avcodec_get_hw_frames_parameters(avctx, device_ref, hw_pix_fmt, out_frames_ref);
		}

		public static string avcodec_get_name(AVCodecID id)
		{
			return vectors.avcodec_get_name(id);
		}

		public unsafe static AVClass* avcodec_get_subtitle_rect_class()
		{
			return vectors.avcodec_get_subtitle_rect_class();
		}

		public unsafe static int avcodec_get_supported_config(AVCodecContext* avctx, AVCodec* codec, AVCodecConfig config, uint flags, void** out_configs, int* out_num_configs)
		{
			return vectors.avcodec_get_supported_config(avctx, codec, config, flags, out_configs, out_num_configs);
		}

		public static AVMediaType avcodec_get_type(AVCodecID codec_id)
		{
			return vectors.avcodec_get_type(codec_id);
		}

		public unsafe static int avcodec_is_open(AVCodecContext* s)
		{
			return vectors.avcodec_is_open(s);
		}

		public static string avcodec_license()
		{
			return vectors.avcodec_license();
		}

		public unsafe static int avcodec_open2(AVCodecContext* avctx, AVCodec* codec, AVDictionary** options)
		{
			return vectors.avcodec_open2(avctx, codec, options);
		}

		public unsafe static AVCodecParameters* avcodec_parameters_alloc()
		{
			return vectors.avcodec_parameters_alloc();
		}

		public unsafe static int avcodec_parameters_copy(AVCodecParameters* dst, AVCodecParameters* src)
		{
			return vectors.avcodec_parameters_copy(dst, src);
		}

		public unsafe static void avcodec_parameters_free(AVCodecParameters** par)
		{
			vectors.avcodec_parameters_free(par);
		}

		public unsafe static int avcodec_parameters_from_context(AVCodecParameters* par, AVCodecContext* codec)
		{
			return vectors.avcodec_parameters_from_context(par, codec);
		}

		public unsafe static int avcodec_parameters_to_context(AVCodecContext* codec, AVCodecParameters* par)
		{
			return vectors.avcodec_parameters_to_context(codec, par);
		}

		public static uint avcodec_pix_fmt_to_codec_tag(AVPixelFormat pix_fmt)
		{
			return vectors.avcodec_pix_fmt_to_codec_tag(pix_fmt);
		}

		public static string avcodec_profile_name(AVCodecID codec_id, int profile)
		{
			return vectors.avcodec_profile_name(codec_id, profile);
		}

		public unsafe static int avcodec_receive_frame(AVCodecContext* avctx, AVFrame* frame)
		{
			return vectors.avcodec_receive_frame(avctx, frame);
		}

		public unsafe static int avcodec_receive_packet(AVCodecContext* avctx, AVPacket* avpkt)
		{
			return vectors.avcodec_receive_packet(avctx, avpkt);
		}

		public unsafe static int avcodec_send_frame(AVCodecContext* avctx, AVFrame* frame)
		{
			return vectors.avcodec_send_frame(avctx, frame);
		}

		public unsafe static int avcodec_send_packet(AVCodecContext* avctx, AVPacket* avpkt)
		{
			return vectors.avcodec_send_packet(avctx, avpkt);
		}

		public unsafe static void avcodec_string(byte* buf, int buf_size, AVCodecContext* enc, int encode)
		{
			vectors.avcodec_string(buf, buf_size, enc, encode);
		}

		public static uint avcodec_version()
		{
			return vectors.avcodec_version();
		}

		public unsafe static int avdevice_app_to_dev_control_message(AVFormatContext* s, AVAppToDevMessageType type, void* data, ulong data_size)
		{
			return vectors.avdevice_app_to_dev_control_message(s, type, data, data_size);
		}

		public static string avdevice_configuration()
		{
			return vectors.avdevice_configuration();
		}

		public unsafe static int avdevice_dev_to_app_control_message(AVFormatContext* s, AVDevToAppMessageType type, void* data, ulong data_size)
		{
			return vectors.avdevice_dev_to_app_control_message(s, type, data, data_size);
		}

		public unsafe static void avdevice_free_list_devices(AVDeviceInfoList** device_list)
		{
			vectors.avdevice_free_list_devices(device_list);
		}

		public static string avdevice_license()
		{
			return vectors.avdevice_license();
		}

		public unsafe static int avdevice_list_devices(AVFormatContext* s, AVDeviceInfoList** device_list)
		{
			return vectors.avdevice_list_devices(s, device_list);
		}

		public unsafe static int avdevice_list_input_sources(AVInputFormat* device, string device_name, AVDictionary* device_options, AVDeviceInfoList** device_list)
		{
			return vectors.avdevice_list_input_sources(device, device_name, device_options, device_list);
		}

		public unsafe static int avdevice_list_output_sinks(AVOutputFormat* device, string device_name, AVDictionary* device_options, AVDeviceInfoList** device_list)
		{
			return vectors.avdevice_list_output_sinks(device, device_name, device_options, device_list);
		}

		public static void avdevice_register_all()
		{
			vectors.avdevice_register_all();
		}

		public static uint avdevice_version()
		{
			return vectors.avdevice_version();
		}

		public static string avfilter_configuration()
		{
			return vectors.avfilter_configuration();
		}

		public unsafe static uint avfilter_filter_pad_count(AVFilter* filter, int is_output)
		{
			return vectors.avfilter_filter_pad_count(filter, is_output);
		}

		public unsafe static void avfilter_free(AVFilterContext* filter)
		{
			vectors.avfilter_free(filter);
		}

		public unsafe static AVFilter* avfilter_get_by_name(string name)
		{
			return vectors.avfilter_get_by_name(name);
		}

		public unsafe static AVClass* avfilter_get_class()
		{
			return vectors.avfilter_get_class();
		}

		public unsafe static AVFilterGraph* avfilter_graph_alloc()
		{
			return vectors.avfilter_graph_alloc();
		}

		public unsafe static AVFilterContext* avfilter_graph_alloc_filter(AVFilterGraph* graph, AVFilter* filter, string name)
		{
			return vectors.avfilter_graph_alloc_filter(graph, filter, name);
		}

		public unsafe static int avfilter_graph_config(AVFilterGraph* graphctx, void* log_ctx)
		{
			return vectors.avfilter_graph_config(graphctx, log_ctx);
		}

		public unsafe static int avfilter_graph_create_filter(AVFilterContext** filt_ctx, AVFilter* filt, string name, string args, void* opaque, AVFilterGraph* graph_ctx)
		{
			return vectors.avfilter_graph_create_filter(filt_ctx, filt, name, args, opaque, graph_ctx);
		}

		public unsafe static byte* avfilter_graph_dump(AVFilterGraph* graph, string options)
		{
			return vectors.avfilter_graph_dump(graph, options);
		}

		public unsafe static void avfilter_graph_free(AVFilterGraph** graph)
		{
			vectors.avfilter_graph_free(graph);
		}

		public unsafe static AVFilterContext* avfilter_graph_get_filter(AVFilterGraph* graph, string name)
		{
			return vectors.avfilter_graph_get_filter(graph, name);
		}

		public unsafe static int avfilter_graph_parse(AVFilterGraph* graph, string filters, AVFilterInOut* inputs, AVFilterInOut* outputs, void* log_ctx)
		{
			return vectors.avfilter_graph_parse(graph, filters, inputs, outputs, log_ctx);
		}

		public unsafe static int avfilter_graph_parse_ptr(AVFilterGraph* graph, string filters, AVFilterInOut** inputs, AVFilterInOut** outputs, void* log_ctx)
		{
			return vectors.avfilter_graph_parse_ptr(graph, filters, inputs, outputs, log_ctx);
		}

		public unsafe static int avfilter_graph_parse2(AVFilterGraph* graph, string filters, AVFilterInOut** inputs, AVFilterInOut** outputs)
		{
			return vectors.avfilter_graph_parse2(graph, filters, inputs, outputs);
		}

		public unsafe static int avfilter_graph_queue_command(AVFilterGraph* graph, string target, string cmd, string arg, int flags, double ts)
		{
			return vectors.avfilter_graph_queue_command(graph, target, cmd, arg, flags, ts);
		}

		public unsafe static int avfilter_graph_request_oldest(AVFilterGraph* graph)
		{
			return vectors.avfilter_graph_request_oldest(graph);
		}

		public unsafe static int avfilter_graph_segment_apply(AVFilterGraphSegment* seg, int flags, AVFilterInOut** inputs, AVFilterInOut** outputs)
		{
			return vectors.avfilter_graph_segment_apply(seg, flags, inputs, outputs);
		}

		public unsafe static int avfilter_graph_segment_apply_opts(AVFilterGraphSegment* seg, int flags)
		{
			return vectors.avfilter_graph_segment_apply_opts(seg, flags);
		}

		public unsafe static int avfilter_graph_segment_create_filters(AVFilterGraphSegment* seg, int flags)
		{
			return vectors.avfilter_graph_segment_create_filters(seg, flags);
		}

		public unsafe static void avfilter_graph_segment_free(AVFilterGraphSegment** seg)
		{
			vectors.avfilter_graph_segment_free(seg);
		}

		public unsafe static int avfilter_graph_segment_init(AVFilterGraphSegment* seg, int flags)
		{
			return vectors.avfilter_graph_segment_init(seg, flags);
		}

		public unsafe static int avfilter_graph_segment_link(AVFilterGraphSegment* seg, int flags, AVFilterInOut** inputs, AVFilterInOut** outputs)
		{
			return vectors.avfilter_graph_segment_link(seg, flags, inputs, outputs);
		}

		public unsafe static int avfilter_graph_segment_parse(AVFilterGraph* graph, string graph_str, int flags, AVFilterGraphSegment** seg)
		{
			return vectors.avfilter_graph_segment_parse(graph, graph_str, flags, seg);
		}

		public unsafe static int avfilter_graph_send_command(AVFilterGraph* graph, string target, string cmd, string arg, byte* res, int res_len, int flags)
		{
			return vectors.avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags);
		}

		public unsafe static void avfilter_graph_set_auto_convert(AVFilterGraph* graph, uint flags)
		{
			vectors.avfilter_graph_set_auto_convert(graph, flags);
		}

		public unsafe static int avfilter_init_dict(AVFilterContext* ctx, AVDictionary** options)
		{
			return vectors.avfilter_init_dict(ctx, options);
		}

		public unsafe static int avfilter_init_str(AVFilterContext* ctx, string args)
		{
			return vectors.avfilter_init_str(ctx, args);
		}

		public unsafe static AVFilterInOut* avfilter_inout_alloc()
		{
			return vectors.avfilter_inout_alloc();
		}

		public unsafe static void avfilter_inout_free(AVFilterInOut** inout)
		{
			vectors.avfilter_inout_free(inout);
		}

		public unsafe static int avfilter_insert_filter(AVFilterLink* link, AVFilterContext* filt, uint filt_srcpad_idx, uint filt_dstpad_idx)
		{
			return vectors.avfilter_insert_filter(link, filt, filt_srcpad_idx, filt_dstpad_idx);
		}

		public static string avfilter_license()
		{
			return vectors.avfilter_license();
		}

		public unsafe static int avfilter_link(AVFilterContext* src, uint srcpad, AVFilterContext* dst, uint dstpad)
		{
			return vectors.avfilter_link(src, srcpad, dst, dstpad);
		}

		public unsafe static AVBufferRef* avfilter_link_get_hw_frames_ctx(AVFilterLink* link)
		{
			return vectors.avfilter_link_get_hw_frames_ctx(link);
		}

		public unsafe static string avfilter_pad_get_name(AVFilterPad* pads, int pad_idx)
		{
			return vectors.avfilter_pad_get_name(pads, pad_idx);
		}

		public unsafe static AVMediaType avfilter_pad_get_type(AVFilterPad* pads, int pad_idx)
		{
			return vectors.avfilter_pad_get_type(pads, pad_idx);
		}

		public unsafe static int avfilter_process_command(AVFilterContext* filter, string cmd, string arg, byte* res, int res_len, int flags)
		{
			return vectors.avfilter_process_command(filter, cmd, arg, res, res_len, flags);
		}

		public static uint avfilter_version()
		{
			return vectors.avfilter_version();
		}

		public unsafe static AVFormatContext* avformat_alloc_context()
		{
			return vectors.avformat_alloc_context();
		}

		public unsafe static int avformat_alloc_output_context2(AVFormatContext** ctx, AVOutputFormat* oformat, string format_name, string filename)
		{
			return vectors.avformat_alloc_output_context2(ctx, oformat, format_name, filename);
		}

		public unsafe static void avformat_close_input(AVFormatContext** s)
		{
			vectors.avformat_close_input(s);
		}

		public static string avformat_configuration()
		{
			return vectors.avformat_configuration();
		}

		public unsafe static int avformat_find_stream_info(AVFormatContext* ic, AVDictionary** options)
		{
			return vectors.avformat_find_stream_info(ic, options);
		}

		public unsafe static int avformat_flush(AVFormatContext* s)
		{
			return vectors.avformat_flush(s);
		}

		public unsafe static void avformat_free_context(AVFormatContext* s)
		{
			vectors.avformat_free_context(s);
		}

		public unsafe static AVClass* avformat_get_class()
		{
			return vectors.avformat_get_class();
		}

		public unsafe static AVCodecTag* avformat_get_mov_audio_tags()
		{
			return vectors.avformat_get_mov_audio_tags();
		}

		public unsafe static AVCodecTag* avformat_get_mov_video_tags()
		{
			return vectors.avformat_get_mov_video_tags();
		}

		public unsafe static AVCodecTag* avformat_get_riff_audio_tags()
		{
			return vectors.avformat_get_riff_audio_tags();
		}

		public unsafe static AVCodecTag* avformat_get_riff_video_tags()
		{
			return vectors.avformat_get_riff_video_tags();
		}

		public unsafe static int avformat_index_get_entries_count(AVStream* st)
		{
			return vectors.avformat_index_get_entries_count(st);
		}

		public unsafe static AVIndexEntry* avformat_index_get_entry(AVStream* st, int idx)
		{
			return vectors.avformat_index_get_entry(st, idx);
		}

		public unsafe static AVIndexEntry* avformat_index_get_entry_from_timestamp(AVStream* st, long wanted_timestamp, int flags)
		{
			return vectors.avformat_index_get_entry_from_timestamp(st, wanted_timestamp, flags);
		}

		public unsafe static int avformat_init_output(AVFormatContext* s, AVDictionary** options)
		{
			return vectors.avformat_init_output(s, options);
		}

		public static string avformat_license()
		{
			return vectors.avformat_license();
		}

		public unsafe static int avformat_match_stream_specifier(AVFormatContext* s, AVStream* st, string spec)
		{
			return vectors.avformat_match_stream_specifier(s, st, spec);
		}

		public static int avformat_network_deinit()
		{
			return vectors.avformat_network_deinit();
		}

		public static int avformat_network_init()
		{
			return vectors.avformat_network_init();
		}

		public unsafe static AVStream* avformat_new_stream(AVFormatContext* s, AVCodec* c)
		{
			return vectors.avformat_new_stream(s, c);
		}

		public unsafe static int avformat_open_input(AVFormatContext** ps, string url, AVInputFormat* fmt, AVDictionary** options)
		{
			return vectors.avformat_open_input(ps, url, fmt, options);
		}

		public unsafe static int avformat_query_codec(AVOutputFormat* ofmt, AVCodecID codec_id, int std_compliance)
		{
			return vectors.avformat_query_codec(ofmt, codec_id, std_compliance);
		}

		public unsafe static int avformat_queue_attached_pictures(AVFormatContext* s)
		{
			return vectors.avformat_queue_attached_pictures(s);
		}

		public unsafe static int avformat_seek_file(AVFormatContext* s, int stream_index, long min_ts, long ts, long max_ts, int flags)
		{
			return vectors.avformat_seek_file(s, stream_index, min_ts, ts, max_ts, flags);
		}

		public unsafe static int avformat_stream_group_add_stream(AVStreamGroup* stg, AVStream* st)
		{
			return vectors.avformat_stream_group_add_stream(stg, st);
		}

		public unsafe static AVStreamGroup* avformat_stream_group_create(AVFormatContext* s, AVStreamGroupParamsType type, AVDictionary** options)
		{
			return vectors.avformat_stream_group_create(s, type, options);
		}

		public static string avformat_stream_group_name(AVStreamGroupParamsType type)
		{
			return vectors.avformat_stream_group_name(type);
		}

		[Obsolete("do not call this function")]
		public unsafe static int avformat_transfer_internal_stream_timing_info(AVOutputFormat* ofmt, AVStream* ost, AVStream* ist, AVTimebaseSource copy_tb)
		{
			return vectors.avformat_transfer_internal_stream_timing_info(ofmt, ost, ist, copy_tb);
		}

		public static uint avformat_version()
		{
			return vectors.avformat_version();
		}

		public unsafe static int avformat_write_header(AVFormatContext* s, AVDictionary** options)
		{
			return vectors.avformat_write_header(s, options);
		}

		public unsafe static int avio_accept(AVIOContext* s, AVIOContext** c)
		{
			return vectors.avio_accept(s, c);
		}

		public unsafe static AVIOContext* avio_alloc_context(byte* buffer, int buffer_size, int write_flag, void* opaque, avio_alloc_context_read_packet_func read_packet, avio_alloc_context_write_packet_func write_packet, avio_alloc_context_seek_func seek)
		{
			return vectors.avio_alloc_context(buffer, buffer_size, write_flag, opaque, read_packet, write_packet, seek);
		}

		public static int avio_check(string url, int flags)
		{
			return vectors.avio_check(url, flags);
		}

		public unsafe static int avio_close(AVIOContext* s)
		{
			return vectors.avio_close(s);
		}

		public unsafe static int avio_close_dir(AVIODirContext** s)
		{
			return vectors.avio_close_dir(s);
		}

		public unsafe static int avio_close_dyn_buf(AVIOContext* s, byte** pbuffer)
		{
			return vectors.avio_close_dyn_buf(s, pbuffer);
		}

		public unsafe static int avio_closep(AVIOContext** s)
		{
			return vectors.avio_closep(s);
		}

		public unsafe static void avio_context_free(AVIOContext** s)
		{
			vectors.avio_context_free(s);
		}

		public unsafe static string avio_enum_protocols(void** opaque, int output)
		{
			return vectors.avio_enum_protocols(opaque, output);
		}

		public unsafe static int avio_feof(AVIOContext* s)
		{
			return vectors.avio_feof(s);
		}

		public static string avio_find_protocol_name(string url)
		{
			return vectors.avio_find_protocol_name(url);
		}

		public unsafe static void avio_flush(AVIOContext* s)
		{
			vectors.avio_flush(s);
		}

		public unsafe static void avio_free_directory_entry(AVIODirEntry** entry)
		{
			vectors.avio_free_directory_entry(entry);
		}

		public unsafe static int avio_get_dyn_buf(AVIOContext* s, byte** pbuffer)
		{
			return vectors.avio_get_dyn_buf(s, pbuffer);
		}

		public unsafe static int avio_get_str(AVIOContext* pb, int maxlen, byte* buf, int buflen)
		{
			return vectors.avio_get_str(pb, maxlen, buf, buflen);
		}

		public unsafe static int avio_get_str16be(AVIOContext* pb, int maxlen, byte* buf, int buflen)
		{
			return vectors.avio_get_str16be(pb, maxlen, buf, buflen);
		}

		public unsafe static int avio_get_str16le(AVIOContext* pb, int maxlen, byte* buf, int buflen)
		{
			return vectors.avio_get_str16le(pb, maxlen, buf, buflen);
		}

		public unsafe static int avio_handshake(AVIOContext* c)
		{
			return vectors.avio_handshake(c);
		}

		public unsafe static int avio_open(AVIOContext** s, string url, int flags)
		{
			return vectors.avio_open(s, url, flags);
		}

		public unsafe static int avio_open_dir(AVIODirContext** s, string url, AVDictionary** options)
		{
			return vectors.avio_open_dir(s, url, options);
		}

		public unsafe static int avio_open_dyn_buf(AVIOContext** s)
		{
			return vectors.avio_open_dyn_buf(s);
		}

		public unsafe static int avio_open2(AVIOContext** s, string url, int flags, AVIOInterruptCB* int_cb, AVDictionary** options)
		{
			return vectors.avio_open2(s, url, flags, int_cb, options);
		}

		public unsafe static int avio_pause(AVIOContext* h, int pause)
		{
			return vectors.avio_pause(h, pause);
		}

		public unsafe static void avio_print_string_array(AVIOContext* s, byte*[] strings)
		{
			vectors.avio_print_string_array(s, strings);
		}

		public unsafe static int avio_printf(AVIOContext* s, string fmt)
		{
			return vectors.avio_printf(s, fmt);
		}

		public unsafe static AVClass* avio_protocol_get_class(string name)
		{
			return vectors.avio_protocol_get_class(name);
		}

		public unsafe static int avio_put_str(AVIOContext* s, string str)
		{
			return vectors.avio_put_str(s, str);
		}

		public unsafe static int avio_put_str16be(AVIOContext* s, string str)
		{
			return vectors.avio_put_str16be(s, str);
		}

		public unsafe static int avio_put_str16le(AVIOContext* s, string str)
		{
			return vectors.avio_put_str16le(s, str);
		}

		public unsafe static int avio_r8(AVIOContext* s)
		{
			return vectors.avio_r8(s);
		}

		public unsafe static uint avio_rb16(AVIOContext* s)
		{
			return vectors.avio_rb16(s);
		}

		public unsafe static uint avio_rb24(AVIOContext* s)
		{
			return vectors.avio_rb24(s);
		}

		public unsafe static uint avio_rb32(AVIOContext* s)
		{
			return vectors.avio_rb32(s);
		}

		public unsafe static ulong avio_rb64(AVIOContext* s)
		{
			return vectors.avio_rb64(s);
		}

		public unsafe static int avio_read(AVIOContext* s, byte* buf, int size)
		{
			return vectors.avio_read(s, buf, size);
		}

		public unsafe static int avio_read_dir(AVIODirContext* s, AVIODirEntry** next)
		{
			return vectors.avio_read_dir(s, next);
		}

		public unsafe static int avio_read_partial(AVIOContext* s, byte* buf, int size)
		{
			return vectors.avio_read_partial(s, buf, size);
		}

		public unsafe static int avio_read_to_bprint(AVIOContext* h, AVBPrint* pb, ulong max_size)
		{
			return vectors.avio_read_to_bprint(h, pb, max_size);
		}

		public unsafe static uint avio_rl16(AVIOContext* s)
		{
			return vectors.avio_rl16(s);
		}

		public unsafe static uint avio_rl24(AVIOContext* s)
		{
			return vectors.avio_rl24(s);
		}

		public unsafe static uint avio_rl32(AVIOContext* s)
		{
			return vectors.avio_rl32(s);
		}

		public unsafe static ulong avio_rl64(AVIOContext* s)
		{
			return vectors.avio_rl64(s);
		}

		public unsafe static long avio_seek(AVIOContext* s, long offset, int whence)
		{
			return vectors.avio_seek(s, offset, whence);
		}

		public unsafe static long avio_seek_time(AVIOContext* h, int stream_index, long timestamp, int flags)
		{
			return vectors.avio_seek_time(h, stream_index, timestamp, flags);
		}

		public unsafe static long avio_size(AVIOContext* s)
		{
			return vectors.avio_size(s);
		}

		public unsafe static long avio_skip(AVIOContext* s, long offset)
		{
			return vectors.avio_skip(s, offset);
		}

		public unsafe static int avio_vprintf(AVIOContext* s, string fmt, byte* ap)
		{
			return vectors.avio_vprintf(s, fmt, ap);
		}

		public unsafe static void avio_w8(AVIOContext* s, int b)
		{
			vectors.avio_w8(s, b);
		}

		public unsafe static void avio_wb16(AVIOContext* s, uint val)
		{
			vectors.avio_wb16(s, val);
		}

		public unsafe static void avio_wb24(AVIOContext* s, uint val)
		{
			vectors.avio_wb24(s, val);
		}

		public unsafe static void avio_wb32(AVIOContext* s, uint val)
		{
			vectors.avio_wb32(s, val);
		}

		public unsafe static void avio_wb64(AVIOContext* s, ulong val)
		{
			vectors.avio_wb64(s, val);
		}

		public unsafe static void avio_wl16(AVIOContext* s, uint val)
		{
			vectors.avio_wl16(s, val);
		}

		public unsafe static void avio_wl24(AVIOContext* s, uint val)
		{
			vectors.avio_wl24(s, val);
		}

		public unsafe static void avio_wl32(AVIOContext* s, uint val)
		{
			vectors.avio_wl32(s, val);
		}

		public unsafe static void avio_wl64(AVIOContext* s, ulong val)
		{
			vectors.avio_wl64(s, val);
		}

		public unsafe static void avio_write(AVIOContext* s, byte* buf, int size)
		{
			vectors.avio_write(s, buf, size);
		}

		public unsafe static void avio_write_marker(AVIOContext* s, long time, AVIODataMarkerType type)
		{
			vectors.avio_write_marker(s, time, type);
		}

		public unsafe static void avsubtitle_free(AVSubtitle* sub)
		{
			vectors.avsubtitle_free(sub);
		}

		public static string avutil_configuration()
		{
			return vectors.avutil_configuration();
		}

		public static string avutil_license()
		{
			return vectors.avutil_license();
		}

		public static uint avutil_version()
		{
			return vectors.avutil_version();
		}

		public unsafe static SwrContext* swr_alloc()
		{
			return vectors.swr_alloc();
		}

		public unsafe static int swr_alloc_set_opts2(SwrContext** ps, AVChannelLayout* out_ch_layout, AVSampleFormat out_sample_fmt, int out_sample_rate, AVChannelLayout* in_ch_layout, AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void* log_ctx)
		{
			return vectors.swr_alloc_set_opts2(ps, out_ch_layout, out_sample_fmt, out_sample_rate, in_ch_layout, in_sample_fmt, in_sample_rate, log_offset, log_ctx);
		}

		public unsafe static int swr_build_matrix2(AVChannelLayout* in_layout, AVChannelLayout* out_layout, double center_mix_level, double surround_mix_level, double lfe_mix_level, double maxval, double rematrix_volume, double* matrix, long stride, AVMatrixEncoding matrix_encoding, void* log_context)
		{
			return vectors.swr_build_matrix2(in_layout, out_layout, center_mix_level, surround_mix_level, lfe_mix_level, maxval, rematrix_volume, matrix, stride, matrix_encoding, log_context);
		}

		public unsafe static void swr_close(SwrContext* s)
		{
			vectors.swr_close(s);
		}

		public unsafe static int swr_config_frame(SwrContext* swr, AVFrame* @out, AVFrame* @in)
		{
			return vectors.swr_config_frame(swr, @out, @in);
		}

		public unsafe static int swr_convert(SwrContext* s, byte** @out, int out_count, byte** @in, int in_count)
		{
			return vectors.swr_convert(s, @out, out_count, @in, in_count);
		}

		public unsafe static int swr_convert_frame(SwrContext* swr, AVFrame* output, AVFrame* input)
		{
			return vectors.swr_convert_frame(swr, output, input);
		}

		public unsafe static int swr_drop_output(SwrContext* s, int count)
		{
			return vectors.swr_drop_output(s, count);
		}

		public unsafe static void swr_free(SwrContext** s)
		{
			vectors.swr_free(s);
		}

		public unsafe static AVClass* swr_get_class()
		{
			return vectors.swr_get_class();
		}

		public unsafe static long swr_get_delay(SwrContext* s, long @base)
		{
			return vectors.swr_get_delay(s, @base);
		}

		public unsafe static int swr_get_out_samples(SwrContext* s, int in_samples)
		{
			return vectors.swr_get_out_samples(s, in_samples);
		}

		public unsafe static int swr_init(SwrContext* s)
		{
			return vectors.swr_init(s);
		}

		public unsafe static int swr_inject_silence(SwrContext* s, int count)
		{
			return vectors.swr_inject_silence(s, count);
		}

		public unsafe static int swr_is_initialized(SwrContext* s)
		{
			return vectors.swr_is_initialized(s);
		}

		public unsafe static long swr_next_pts(SwrContext* s, long pts)
		{
			return vectors.swr_next_pts(s, pts);
		}

		public unsafe static int swr_set_channel_mapping(SwrContext* s, int* channel_map)
		{
			return vectors.swr_set_channel_mapping(s, channel_map);
		}

		public unsafe static int swr_set_compensation(SwrContext* s, int sample_delta, int compensation_distance)
		{
			return vectors.swr_set_compensation(s, sample_delta, compensation_distance);
		}

		public unsafe static int swr_set_matrix(SwrContext* s, double* matrix, int stride)
		{
			return vectors.swr_set_matrix(s, matrix, stride);
		}

		public static string swresample_configuration()
		{
			return vectors.swresample_configuration();
		}

		public static string swresample_license()
		{
			return vectors.swresample_license();
		}

		public static uint swresample_version()
		{
			return vectors.swresample_version();
		}

		public unsafe static SwsContext* sws_alloc_context()
		{
			return vectors.sws_alloc_context();
		}

		public unsafe static SwsVector* sws_allocVec(int length)
		{
			return vectors.sws_allocVec(length);
		}

		public unsafe static void sws_convertPalette8ToPacked24(byte* src, byte* dst, int num_pixels, byte* palette)
		{
			vectors.sws_convertPalette8ToPacked24(src, dst, num_pixels, palette);
		}

		public unsafe static void sws_convertPalette8ToPacked32(byte* src, byte* dst, int num_pixels, byte* palette)
		{
			vectors.sws_convertPalette8ToPacked32(src, dst, num_pixels, palette);
		}

		public unsafe static void sws_frame_end(SwsContext* c)
		{
			vectors.sws_frame_end(c);
		}

		public unsafe static int sws_frame_setup(SwsContext* ctx, AVFrame* dst, AVFrame* src)
		{
			return vectors.sws_frame_setup(ctx, dst, src);
		}

		public unsafe static int sws_frame_start(SwsContext* c, AVFrame* dst, AVFrame* src)
		{
			return vectors.sws_frame_start(c, dst, src);
		}

		public unsafe static void sws_free_context(SwsContext** ctx)
		{
			vectors.sws_free_context(ctx);
		}

		public unsafe static void sws_freeContext(SwsContext* swsContext)
		{
			vectors.sws_freeContext(swsContext);
		}

		public unsafe static void sws_freeFilter(SwsFilter* filter)
		{
			vectors.sws_freeFilter(filter);
		}

		public unsafe static void sws_freeVec(SwsVector* a)
		{
			vectors.sws_freeVec(a);
		}

		public unsafe static AVClass* sws_get_class()
		{
			return vectors.sws_get_class();
		}

		public unsafe static SwsContext* sws_getCachedContext(SwsContext* context, int srcW, int srcH, AVPixelFormat srcFormat, int dstW, int dstH, AVPixelFormat dstFormat, int flags, SwsFilter* srcFilter, SwsFilter* dstFilter, double* param)
		{
			return vectors.sws_getCachedContext(context, srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, srcFilter, dstFilter, param);
		}

		public unsafe static int* sws_getCoefficients(int colorspace)
		{
			return vectors.sws_getCoefficients(colorspace);
		}

		public unsafe static int sws_getColorspaceDetails(SwsContext* c, int** inv_table, int* srcRange, int** table, int* dstRange, int* brightness, int* contrast, int* saturation)
		{
			return vectors.sws_getColorspaceDetails(c, inv_table, srcRange, table, dstRange, brightness, contrast, saturation);
		}

		public unsafe static SwsContext* sws_getContext(int srcW, int srcH, AVPixelFormat srcFormat, int dstW, int dstH, AVPixelFormat dstFormat, int flags, SwsFilter* srcFilter, SwsFilter* dstFilter, double* param)
		{
			return vectors.sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, srcFilter, dstFilter, param);
		}

		public unsafe static SwsFilter* sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose)
		{
			return vectors.sws_getDefaultFilter(lumaGBlur, chromaGBlur, lumaSharpen, chromaSharpen, chromaHShift, chromaVShift, verbose);
		}

		public unsafe static SwsVector* sws_getGaussianVec(double variance, double quality)
		{
			return vectors.sws_getGaussianVec(variance, quality);
		}

		public unsafe static int sws_init_context(SwsContext* sws_context, SwsFilter* srcFilter, SwsFilter* dstFilter)
		{
			return vectors.sws_init_context(sws_context, srcFilter, dstFilter);
		}

		public unsafe static int sws_is_noop(AVFrame* dst, AVFrame* src)
		{
			return vectors.sws_is_noop(dst, src);
		}

		public static int sws_isSupportedEndiannessConversion(AVPixelFormat pix_fmt)
		{
			return vectors.sws_isSupportedEndiannessConversion(pix_fmt);
		}

		public static int sws_isSupportedInput(AVPixelFormat pix_fmt)
		{
			return vectors.sws_isSupportedInput(pix_fmt);
		}

		public static int sws_isSupportedOutput(AVPixelFormat pix_fmt)
		{
			return vectors.sws_isSupportedOutput(pix_fmt);
		}

		public unsafe static void sws_normalizeVec(SwsVector* a, double height)
		{
			vectors.sws_normalizeVec(a, height);
		}

		public unsafe static int sws_receive_slice(SwsContext* c, uint slice_start, uint slice_height)
		{
			return vectors.sws_receive_slice(c, slice_start, slice_height);
		}

		public unsafe static uint sws_receive_slice_alignment(SwsContext* c)
		{
			return vectors.sws_receive_slice_alignment(c);
		}

		public unsafe static int sws_scale(SwsContext* c, byte*[] srcSlice, int[] srcStride, int srcSliceY, int srcSliceH, byte*[] dst, int[] dstStride)
		{
			return vectors.sws_scale(c, srcSlice, srcStride, srcSliceY, srcSliceH, dst, dstStride);
		}

		public unsafe static int sws_scale_frame(SwsContext* c, AVFrame* dst, AVFrame* src)
		{
			return vectors.sws_scale_frame(c, dst, src);
		}

		public unsafe static void sws_scaleVec(SwsVector* a, double scalar)
		{
			vectors.sws_scaleVec(a, scalar);
		}

		public unsafe static int sws_send_slice(SwsContext* c, uint slice_start, uint slice_height)
		{
			return vectors.sws_send_slice(c, slice_start, slice_height);
		}

		public unsafe static int sws_setColorspaceDetails(SwsContext* c, in int_array4 inv_table, int srcRange, in int_array4 table, int dstRange, int brightness, int contrast, int saturation)
		{
			return vectors.sws_setColorspaceDetails(c, in inv_table, srcRange, in table, dstRange, brightness, contrast, saturation);
		}

		public static int sws_test_colorspace(AVColorSpace colorspace, int output)
		{
			return vectors.sws_test_colorspace(colorspace, output);
		}

		public static int sws_test_format(AVPixelFormat format, int output)
		{
			return vectors.sws_test_format(format, output);
		}

		public unsafe static int sws_test_frame(AVFrame* frame, int output)
		{
			return vectors.sws_test_frame(frame, output);
		}

		public static int sws_test_primaries(AVColorPrimaries primaries, int output)
		{
			return vectors.sws_test_primaries(primaries, output);
		}

		public static int sws_test_transfer(AVColorTransferCharacteristic trc, int output)
		{
			return vectors.sws_test_transfer(trc, output);
		}

		public static string swscale_configuration()
		{
			return vectors.swscale_configuration();
		}

		public static string swscale_license()
		{
			return vectors.swscale_license();
		}

		public static uint swscale_version()
		{
			return vectors.swscale_version();
		}

		public static int av_ceil_log2_c(int x)
		{
			return av_log2((uint)((int)((long)x - 1L) << 1));
		}

		public static int av_clip_c(int a, int amin, int amax)
		{
			if (a < amin)
			{
				return amin;
			}
			if (a > amax)
			{
				return amax;
			}
			return a;
		}

		public static short av_clip_int16_c(int a)
		{
			if ((((long)a + 32768L) & -65536) != 0L)
			{
				return (short)((a >> 31) ^ 0x7FFF);
			}
			return (short)a;
		}

		public static sbyte av_clip_int8_c(int a)
		{
			if ((((long)a + 128L) & -256) != 0L)
			{
				return (sbyte)((a >> 31) ^ 0x7F);
			}
			return (sbyte)a;
		}

		public static int av_clip_intp2_c(int a, int p)
		{
			if (((a + (1 << p)) & ~((2 << p) - 1)) != 0)
			{
				return (a >> 31) ^ ((1 << p) - 1);
			}
			return a;
		}

		public static ushort av_clip_uint16_c(int a)
		{
			if (((uint)a & 0xFFFF0000u) != 0)
			{
				return (ushort)(~a >> 31);
			}
			return (ushort)a;
		}

		public static byte av_clip_uint8_c(int a)
		{
			if (((uint)a & 0xFFFFFF00u) != 0)
			{
				return (byte)(~a >> 31);
			}
			return (byte)a;
		}

		public static uint av_clip_uintp2_c(int a, int p)
		{
			if ((a & (uint)(~((1 << p) - 1))) != 0L)
			{
				return ((uint)(~a) >> 31) & (uint)((1 << p) - 1);
			}
			return (uint)a;
		}

		public static long av_clip64_c(long a, long amin, long amax)
		{
			if (a < amin)
			{
				return amin;
			}
			if (a > amax)
			{
				return amax;
			}
			return a;
		}

		public static double av_clipd_c(double a, double amin, double amax)
		{
			if (!(((a > amin) ? a : amin) > amax))
			{
				if (!(a > amin))
				{
					return amin;
				}
				return a;
			}
			return amax;
		}

		public static float av_clipf_c(float a, float amin, float amax)
		{
			if (!(((a > amin) ? a : amin) > amax))
			{
				if (!(a > amin))
				{
					return amin;
				}
				return a;
			}
			return amax;
		}

		public static int av_clipl_int32_c(long a)
		{
			if (((a + 2147483648u) & -4294967296L) != 0L)
			{
				return (int)((a >> 63) ^ 0x7FFFFFFF);
			}
			return (int)a;
		}

		public static int av_cmp_q(AVRational a, AVRational b)
		{
			long num = (long)a.num * (long)b.den - (long)b.num * (long)a.den;
			if (num != 0L)
			{
				return (int)((num ^ a.den ^ b.den) >> 63) | 1;
			}
			if (b.den != 0 && a.den != 0)
			{
				return 0;
			}
			if (a.num != 0 && b.num != 0)
			{
				return (a.num >> 31) - (b.num >> 31);
			}
			return int.MinValue;
		}

		public static ulong av_double2int(double f)
		{
			return (ulong)f;
		}

		public static uint av_float2int(float f)
		{
			return (uint)f;
		}

		public unsafe static AVFrameSideData* av_frame_side_data_get(AVFrameSideData** sd, int nb_sd, AVFrameSideDataType type)
		{
			return av_frame_side_data_get_c(sd, nb_sd, type);
		}

		public static void av_image_copy2(ref byte_ptrArray4 dst_data, in int_array4 dst_linesizes, ref byte_ptrArray4 src_data, in int_array4 src_linesizes, AVPixelFormat pix_fmt, int width, int height)
		{
			av_image_copy(ref dst_data, in dst_linesizes, in src_data, in src_linesizes, pix_fmt, width, height);
		}

		public static double av_int2double(ulong i)
		{
			return i;
		}

		public static float av_int2float(uint i)
		{
			return i;
		}

		public static AVRational av_inv_q(AVRational q)
		{
			AVRational result = default(AVRational);
			result.num = q.den;
			result.den = q.num;
			return result;
		}

		public unsafe static byte* av_make_error_string(byte* errbuf, ulong errbuf_size, int errnum)
		{
			av_strerror(errnum, errbuf, errbuf_size);
			return errbuf;
		}

		public static AVRational av_make_q(int num, int den)
		{
			AVRational result = default(AVRational);
			result.num = num;
			result.den = den;
			return result;
		}

		[Obsolete]
		public static uint av_mod_uintp2_c(uint a, uint p)
		{
			return av_zero_extend_c(a, p);
		}

		public static int av_parity_c(uint v)
		{
			return av_popcount_c(v) & 1;
		}

		public static int av_popcount_c(uint x)
		{
			x -= (x >> 1) & 0x55555555;
			x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
			x = (x + (x >> 4)) & 0xF0F0F0Fu;
			x += x >> 8;
			return (int)((x + (x >> 16)) & 0x3F);
		}

		public static int av_popcount64_c(ulong x)
		{
			return av_popcount_c((uint)x) + av_popcount_c((uint)(x >> 32));
		}

		public static double av_q2d(AVRational a)
		{
			return (double)a.num / (double)a.den;
		}

		public static int av_sat_add32_c(int a, int b)
		{
			return av_clipl_int32_c((long)a + (long)b);
		}

		public static long av_sat_add64_c(long a, long b)
		{
			try
			{
				return a + b;
			}
			catch (OverflowException)
			{
				return ((double)a + (double)b > 0.0) ? long.MaxValue : long.MinValue;
			}
		}

		public static int av_sat_dadd32_c(int a, int b)
		{
			return av_sat_add32_c(a, av_sat_add32_c(b, b));
		}

		public static int av_sat_dsub32_c(int a, int b)
		{
			return av_sat_sub32_c(a, av_sat_add32_c(b, b));
		}

		public static int av_sat_sub32_c(int a, int b)
		{
			return av_clipl_int32_c((long)a - (long)b);
		}

		public static long av_sat_sub64_c(long a, long b)
		{
			try
			{
				return a - b;
			}
			catch (OverflowException)
			{
				return ((double)a - (double)b > 0.0) ? long.MaxValue : long.MinValue;
			}
		}

		public unsafe static void* av_x_if_null(void* p, void* x)
		{
			if (p == null)
			{
				return x;
			}
			return p;
		}

		public static uint av_zero_extend_c(uint a, uint p)
		{
			return a & (uint)((1 << (int)p) - 1);
		}

		public unsafe static long avio_tell(AVIOContext* s)
		{
			return avio_seek(s, 0L, 1);
		}
	}
	public abstract class FunctionResolverBase : IFunctionResolver
	{
		public static readonly Dictionary<string, string[]> LibraryDependenciesMap = new Dictionary<string, string[]>
		{
			{
				"avcodec",
				new string[2] { "avutil", "swresample" }
			},
			{
				"avdevice",
				new string[4] { "avcodec", "avfilter", "avformat", "avutil" }
			},
			{
				"avfilter",
				new string[5] { "avcodec", "avformat", "avutil", "swresample", "swscale" }
			},
			{
				"avformat",
				new string[2] { "avcodec", "avutil" }
			},
			{
				"avutil",
				new string[0]
			},
			{
				"swresample",
				new string[1] { "avutil" }
			},
			{
				"swscale",
				new string[1] { "avutil" }
			}
		};

		private readonly Dictionary<string, IntPtr> _loadedLibraries = new Dictionary<string, IntPtr>();

		private readonly object _syncRoot = new object();

		public T GetFunctionDelegate<T>(string libraryName, string functionName, bool throwOnError = true)
		{
			IntPtr orLoadLibrary = GetOrLoadLibrary(libraryName, throwOnError);
			return GetFunctionDelegate<T>(orLoadLibrary, functionName, throwOnError);
		}

		public T GetFunctionDelegate<T>(IntPtr nativeLibraryHandle, string functionName, bool throwOnError)
		{
			IntPtr intPtr = FindFunctionPointer(nativeLibraryHandle, functionName);
			if (intPtr == IntPtr.Zero)
			{
				if (throwOnError)
				{
					throw new EntryPointNotFoundException("Could not find the entrypoint for " + functionName + ".");
				}
				return default(T);
			}
			try
			{
				return Marshal.GetDelegateForFunctionPointer<T>(intPtr);
			}
			catch (MarshalDirectiveException)
			{
				if (throwOnError)
				{
					throw;
				}
				return default(T);
			}
		}

		public IntPtr GetOrLoadLibrary(string libraryName, bool throwOnError)
		{
			if (_loadedLibraries.TryGetValue(libraryName, out var value))
			{
				return value;
			}
			lock (_syncRoot)
			{
				if (_loadedLibraries.TryGetValue(libraryName, out value))
				{
					return value;
				}
				LibraryDependenciesMap[libraryName].Where((string n) => !_loadedLibraries.ContainsKey(n) && !n.Equals(libraryName)).ToList().ForEach(delegate(string n)
				{
					GetOrLoadLibrary(n, throwOnError: false);
				});
				int num = ffmpeg.LibraryVersionMap[libraryName];
				string nativeLibraryName = GetNativeLibraryName(libraryName, num);
				string libraryName2 = Path.Combine(ffmpeg.RootPath, nativeLibraryName);
				value = LoadNativeLibrary(libraryName2);
				if (value != IntPtr.Zero)
				{
					_loadedLibraries.Add(libraryName, value);
				}
				else if (throwOnError)
				{
					throw new DllNotFoundException($"Unable to load DLL '{libraryName}.{num} under {ffmpeg.RootPath}': The specified module could not be found.");
				}
				return value;
			}
		}

		protected abstract string GetNativeLibraryName(string libraryName, int version);

		protected abstract IntPtr LoadNativeLibrary(string libraryName);

		protected abstract IntPtr FindFunctionPointer(IntPtr nativeLibraryHandle, string functionName);
	}
	public static class FunctionResolverFactory
	{
		public static PlatformID GetPlatformId()
		{
			if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
			{
				return PlatformID.Win32NT;
			}
			if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
			{
				return PlatformID.Unix;
			}
			if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
			{
				return PlatformID.MacOSX;
			}
			throw new PlatformNotSupportedException();
		}

		public static IFunctionResolver Create()
		{
			return GetPlatformId() switch
			{
				PlatformID.MacOSX => new MacFunctionResolver(), 
				PlatformID.Unix => new LinuxFunctionResolver(), 
				PlatformID.Win32NT => new WindowsFunctionResolver(), 
				_ => throw new PlatformNotSupportedException(), 
			};
		}
	}
	public struct AVRational_array2 : IFixedArray<AVRational>, IFixedArray
	{
		public static readonly int Size = 2;

		private AVRational _0;

		private AVRational _1;

		public int Length => 2;

		public unsafe AVRational this[uint i]
		{
			get
			{
				if (i >= 2)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 2)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVRational[] ToArray()
		{
			fixed (AVRational* ptr = &_0)
			{
				AVRational[] array = new AVRational[2];
				for (uint num = 0u; num < 2; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVRational[] array)
		{
			fixed (AVRational* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVRational aVRational in array)
				{
					ptr[num++] = aVRational;
					if (num >= 2)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVRational[](AVRational_array2 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct double_array2 : IFixedArray<double>, IFixedArray
	{
		public static readonly int Size = 2;

		private unsafe fixed double _[2];

		public int Length => 2;

		public unsafe double this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe double[] ToArray()
		{
			double[] array = new double[2];
			for (uint num = 0u; num < 2; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(double[] array)
		{
			uint num = 0u;
			foreach (double num2 in array)
			{
				_[num++] = num2;
				if (num >= 2)
				{
					break;
				}
			}
		}

		public static implicit operator double[](double_array2 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct short_array2 : IFixedArray<short>, IFixedArray
	{
		public static readonly int Size = 2;

		private unsafe fixed short _[2];

		public int Length => 2;

		public unsafe short this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe short[] ToArray()
		{
			short[] array = new short[2];
			for (uint num = 0u; num < 2; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(short[] array)
		{
			uint num = 0u;
			foreach (short num2 in array)
			{
				_[num++] = num2;
				if (num >= 2)
				{
					break;
				}
			}
		}

		public static implicit operator short[](short_array2 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct void_ptrArray2 : IFixedArray
	{
		public static readonly int Size = 2;

		private unsafe void* _0;

		private unsafe void* _1;

		public int Length => 2;

		public unsafe void* this[uint i]
		{
			get
			{
				if (i >= 2)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (void** ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 2)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (void** ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe void*[] ToArray()
		{
			fixed (void** ptr = &_0)
			{
				void*[] array = new void*[2];
				for (uint num = 0u; num < 2; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(void*[] array)
		{
			fixed (void** ptr2 = &_0)
			{
				uint num = 0u;
				foreach (void* ptr in array)
				{
					ptr2[num++] = ptr;
					if (num >= 2)
					{
						return;
					}
				}
			}
		}

		public unsafe static implicit operator void*[](void_ptrArray2 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVHDRPlusColorTransformParams_array3 : IFixedArray<AVHDRPlusColorTransformParams>, IFixedArray
	{
		public static readonly int Size = 3;

		private AVHDRPlusColorTransformParams _0;

		private AVHDRPlusColorTransformParams _1;

		private AVHDRPlusColorTransformParams _2;

		public int Length => 3;

		public unsafe AVHDRPlusColorTransformParams this[uint i]
		{
			get
			{
				if (i >= 3)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVHDRPlusColorTransformParams* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 3)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVHDRPlusColorTransformParams* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVHDRPlusColorTransformParams[] ToArray()
		{
			fixed (AVHDRPlusColorTransformParams* ptr = &_0)
			{
				AVHDRPlusColorTransformParams[] array = new AVHDRPlusColorTransformParams[3];
				for (uint num = 0u; num < 3; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVHDRPlusColorTransformParams[] array)
		{
			fixed (AVHDRPlusColorTransformParams* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVHDRPlusColorTransformParams aVHDRPlusColorTransformParams in array)
				{
					ptr[num++] = aVHDRPlusColorTransformParams;
					if (num >= 3)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVHDRPlusColorTransformParams[](AVHDRPlusColorTransformParams_array3 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVRational_array3 : IFixedArray<AVRational>, IFixedArray
	{
		public static readonly int Size = 3;

		private AVRational _0;

		private AVRational _1;

		private AVRational _2;

		public int Length => 3;

		public unsafe AVRational this[uint i]
		{
			get
			{
				if (i >= 3)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 3)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVRational[] ToArray()
		{
			fixed (AVRational* ptr = &_0)
			{
				AVRational[] array = new AVRational[3];
				for (uint num = 0u; num < 3; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVRational[] array)
		{
			fixed (AVRational* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVRational aVRational in array)
				{
					ptr[num++] = aVRational;
					if (num >= 3)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVRational[](AVRational_array3 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVRational_array3x2 : IFixedArray<AVRational_array2>, IFixedArray
	{
		public static readonly int Size = 3;

		private AVRational_array2 _0;

		private AVRational_array2 _1;

		private AVRational_array2 _2;

		public int Length => 3;

		public unsafe AVRational_array2 this[uint i]
		{
			get
			{
				if (i >= 3)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational_array2* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 3)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational_array2* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVRational_array2[] ToArray()
		{
			fixed (AVRational_array2* ptr = &_0)
			{
				AVRational_array2[] array = new AVRational_array2[3];
				for (uint num = 0u; num < 3; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVRational_array2[] array)
		{
			fixed (AVRational_array2* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVRational_array2 aVRational_array in array)
				{
					ptr[num++] = aVRational_array;
					if (num >= 3)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVRational_array2[](AVRational_array3x2 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct short_array3x2 : IFixedArray<short_array2>, IFixedArray
	{
		public static readonly int Size = 3;

		private short_array2 _0;

		private short_array2 _1;

		private short_array2 _2;

		public int Length => 3;

		public unsafe short_array2 this[uint i]
		{
			get
			{
				if (i >= 3)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (short_array2* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 3)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (short_array2* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe short_array2[] ToArray()
		{
			fixed (short_array2* ptr = &_0)
			{
				short_array2[] array = new short_array2[3];
				for (uint num = 0u; num < 3; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(short_array2[] array)
		{
			fixed (short_array2* ptr = &_0)
			{
				uint num = 0u;
				foreach (short_array2 short_array3 in array)
				{
					ptr[num++] = short_array3;
					if (num >= 3)
					{
						return;
					}
				}
			}
		}

		public static implicit operator short_array2[](short_array3x2 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVComponentDescriptor_array4 : IFixedArray<AVComponentDescriptor>, IFixedArray
	{
		public static readonly int Size = 4;

		private AVComponentDescriptor _0;

		private AVComponentDescriptor _1;

		private AVComponentDescriptor _2;

		private AVComponentDescriptor _3;

		public int Length => 4;

		public unsafe AVComponentDescriptor this[uint i]
		{
			get
			{
				if (i >= 4)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVComponentDescriptor* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 4)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVComponentDescriptor* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVComponentDescriptor[] ToArray()
		{
			fixed (AVComponentDescriptor* ptr = &_0)
			{
				AVComponentDescriptor[] array = new AVComponentDescriptor[4];
				for (uint num = 0u; num < 4; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVComponentDescriptor[] array)
		{
			fixed (AVComponentDescriptor* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVComponentDescriptor aVComponentDescriptor in array)
				{
					ptr[num++] = aVComponentDescriptor;
					if (num >= 4)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVComponentDescriptor[](AVComponentDescriptor_array4 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct byte_ptrArray4 : IFixedArray
	{
		public static readonly int Size = 4;

		private unsafe byte* _0;

		private unsafe byte* _1;

		private unsafe byte* _2;

		private unsafe byte* _3;

		public int Length => 4;

		public unsafe byte* this[uint i]
		{
			get
			{
				if (i >= 4)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (byte** ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 4)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (byte** ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe byte*[] ToArray()
		{
			fixed (byte** ptr = &_0)
			{
				byte*[] array = new byte*[4];
				for (uint num = 0u; num < 4; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(byte*[] array)
		{
			fixed (byte** ptr2 = &_0)
			{
				uint num = 0u;
				foreach (byte* ptr in array)
				{
					ptr2[num++] = ptr;
					if (num >= 4)
					{
						return;
					}
				}
			}
		}

		public unsafe static implicit operator byte*[](byte_ptrArray4 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct byte_array4 : IFixedArray<byte>, IFixedArray
	{
		public static readonly int Size = 4;

		private unsafe fixed byte _[4];

		public int Length => 4;

		public unsafe byte this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe byte[] ToArray()
		{
			byte[] array = new byte[4];
			for (uint num = 0u; num < 4; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(byte[] array)
		{
			uint num = 0u;
			foreach (byte b in array)
			{
				_[num++] = b;
				if (num >= 4)
				{
					break;
				}
			}
		}

		public static implicit operator byte[](byte_array4 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct int_array4 : IFixedArray<int>, IFixedArray
	{
		public static readonly int Size = 4;

		private unsafe fixed int _[4];

		public int Length => 4;

		public unsafe int this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe int[] ToArray()
		{
			int[] array = new int[4];
			for (uint num = 0u; num < 4; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(int[] array)
		{
			uint num = 0u;
			foreach (int num2 in array)
			{
				_[num++] = num2;
				if (num >= 4)
				{
					break;
				}
			}
		}

		public static implicit operator int[](int_array4 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct long_array4 : IFixedArray<long>, IFixedArray
	{
		public static readonly int Size = 4;

		private unsafe fixed long _[4];

		public int Length => 4;

		public unsafe long this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe long[] ToArray()
		{
			long[] array = new long[4];
			for (uint num = 0u; num < 4; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(long[] array)
		{
			uint num = 0u;
			foreach (long num2 in array)
			{
				_[num++] = num2;
				if (num >= 4)
				{
					break;
				}
			}
		}

		public static implicit operator long[](long_array4 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct uint_array4 : IFixedArray<uint>, IFixedArray
	{
		public static readonly int Size = 4;

		private unsafe fixed uint _[4];

		public int Length => 4;

		public unsafe uint this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe uint[] ToArray()
		{
			uint[] array = new uint[4];
			for (uint num = 0u; num < 4; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(uint[] array)
		{
			uint num = 0u;
			foreach (uint num2 in array)
			{
				_[num++] = num2;
				if (num >= 4)
				{
					break;
				}
			}
		}

		public static implicit operator uint[](uint_array4 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct ulong_array4 : IFixedArray<ulong>, IFixedArray
	{
		public static readonly int Size = 4;

		private unsafe fixed ulong _[4];

		public int Length => 4;

		public unsafe ulong this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe ulong[] ToArray()
		{
			ulong[] array = new ulong[4];
			for (uint num = 0u; num < 4; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(ulong[] array)
		{
			uint num = 0u;
			foreach (ulong num2 in array)
			{
				_[num++] = num2;
				if (num >= 4)
				{
					break;
				}
			}
		}

		public static implicit operator ulong[](ulong_array4 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct int_array7 : IFixedArray<int>, IFixedArray
	{
		public static readonly int Size = 7;

		private unsafe fixed int _[7];

		public int Length => 7;

		public unsafe int this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe int[] ToArray()
		{
			int[] array = new int[7];
			for (uint num = 0u; num < 7; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(int[] array)
		{
			uint num = 0u;
			foreach (int num2 in array)
			{
				_[num++] = num2;
				if (num >= 7)
				{
					break;
				}
			}
		}

		public static implicit operator int[](int_array7 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVBufferRef_ptrArray8 : IFixedArray
	{
		public static readonly int Size = 8;

		private unsafe AVBufferRef* _0;

		private unsafe AVBufferRef* _1;

		private unsafe AVBufferRef* _2;

		private unsafe AVBufferRef* _3;

		private unsafe AVBufferRef* _4;

		private unsafe AVBufferRef* _5;

		private unsafe AVBufferRef* _6;

		private unsafe AVBufferRef* _7;

		public int Length => 8;

		public unsafe AVBufferRef* this[uint i]
		{
			get
			{
				if (i >= 8)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVBufferRef** ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 8)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVBufferRef** ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVBufferRef*[] ToArray()
		{
			fixed (AVBufferRef** ptr = &_0)
			{
				AVBufferRef*[] array = new AVBufferRef*[8];
				for (uint num = 0u; num < 8; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVBufferRef*[] array)
		{
			fixed (AVBufferRef** ptr2 = &_0)
			{
				uint num = 0u;
				foreach (AVBufferRef* ptr in array)
				{
					ptr2[num++] = ptr;
					if (num >= 8)
					{
						return;
					}
				}
			}
		}

		public unsafe static implicit operator AVBufferRef*[](AVBufferRef_ptrArray8 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct byte_ptrArray8 : IFixedArray
	{
		public static readonly int Size = 8;

		private unsafe byte* _0;

		private unsafe byte* _1;

		private unsafe byte* _2;

		private unsafe byte* _3;

		private unsafe byte* _4;

		private unsafe byte* _5;

		private unsafe byte* _6;

		private unsafe byte* _7;

		public int Length => 8;

		public unsafe byte* this[uint i]
		{
			get
			{
				if (i >= 8)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (byte** ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 8)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (byte** ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe byte*[] ToArray()
		{
			fixed (byte** ptr = &_0)
			{
				byte*[] array = new byte*[8];
				for (uint num = 0u; num < 8; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(byte*[] array)
		{
			fixed (byte** ptr2 = &_0)
			{
				uint num = 0u;
				foreach (byte* ptr in array)
				{
					ptr2[num++] = ptr;
					if (num >= 8)
					{
						return;
					}
				}
			}
		}

		public unsafe static implicit operator byte*[](byte_ptrArray8 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct byte_array8 : IFixedArray<byte>, IFixedArray
	{
		public static readonly int Size = 8;

		private unsafe fixed byte _[8];

		public int Length => 8;

		public unsafe byte this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe byte[] ToArray()
		{
			byte[] array = new byte[8];
			for (uint num = 0u; num < 8; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(byte[] array)
		{
			uint num = 0u;
			foreach (byte b in array)
			{
				_[num++] = b;
				if (num >= 8)
				{
					break;
				}
			}
		}

		public static implicit operator byte[](byte_array8 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct int_array8 : IFixedArray<int>, IFixedArray
	{
		public static readonly int Size = 8;

		private unsafe fixed int _[8];

		public int Length => 8;

		public unsafe int this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe int[] ToArray()
		{
			int[] array = new int[8];
			for (uint num = 0u; num < 8; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(int[] array)
		{
			uint num = 0u;
			foreach (int num2 in array)
			{
				_[num++] = num2;
				if (num >= 8)
				{
					break;
				}
			}
		}

		public static implicit operator int[](int_array8 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct ulong_array8 : IFixedArray<ulong>, IFixedArray
	{
		public static readonly int Size = 8;

		private unsafe fixed ulong _[8];

		public int Length => 8;

		public unsafe ulong this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe ulong[] ToArray()
		{
			ulong[] array = new ulong[8];
			for (uint num = 0u; num < 8; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(ulong[] array)
		{
			uint num = 0u;
			foreach (ulong num2 in array)
			{
				_[num++] = num2;
				if (num >= 8)
				{
					break;
				}
			}
		}

		public static implicit operator ulong[](ulong_array8 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct int_array9 : IFixedArray<int>, IFixedArray
	{
		public static readonly int Size = 9;

		private unsafe fixed int _[9];

		public int Length => 9;

		public unsafe int this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe int[] ToArray()
		{
			int[] array = new int[9];
			for (uint num = 0u; num < 9; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(int[] array)
		{
			uint num = 0u;
			foreach (int num2 in array)
			{
				_[num++] = num2;
				if (num >= 9)
				{
					break;
				}
			}
		}

		public static implicit operator int[](int_array9 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVHDRPlusPercentile_array15 : IFixedArray<AVHDRPlusPercentile>, IFixedArray
	{
		public static readonly int Size = 15;

		private AVHDRPlusPercentile _0;

		private AVHDRPlusPercentile _1;

		private AVHDRPlusPercentile _2;

		private AVHDRPlusPercentile _3;

		private AVHDRPlusPercentile _4;

		private AVHDRPlusPercentile _5;

		private AVHDRPlusPercentile _6;

		private AVHDRPlusPercentile _7;

		private AVHDRPlusPercentile _8;

		private AVHDRPlusPercentile _9;

		private AVHDRPlusPercentile _10;

		private AVHDRPlusPercentile _11;

		private AVHDRPlusPercentile _12;

		private AVHDRPlusPercentile _13;

		private AVHDRPlusPercentile _14;

		public int Length => 15;

		public unsafe AVHDRPlusPercentile this[uint i]
		{
			get
			{
				if (i >= 15)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVHDRPlusPercentile* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 15)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVHDRPlusPercentile* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVHDRPlusPercentile[] ToArray()
		{
			fixed (AVHDRPlusPercentile* ptr = &_0)
			{
				AVHDRPlusPercentile[] array = new AVHDRPlusPercentile[15];
				for (uint num = 0u; num < 15; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVHDRPlusPercentile[] array)
		{
			fixed (AVHDRPlusPercentile* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVHDRPlusPercentile aVHDRPlusPercentile in array)
				{
					ptr[num++] = aVHDRPlusPercentile;
					if (num >= 15)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVHDRPlusPercentile[](AVHDRPlusPercentile_array15 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVRational_array15 : IFixedArray<AVRational>, IFixedArray
	{
		public static readonly int Size = 15;

		private AVRational _0;

		private AVRational _1;

		private AVRational _2;

		private AVRational _3;

		private AVRational _4;

		private AVRational _5;

		private AVRational _6;

		private AVRational _7;

		private AVRational _8;

		private AVRational _9;

		private AVRational _10;

		private AVRational _11;

		private AVRational _12;

		private AVRational _13;

		private AVRational _14;

		public int Length => 15;

		public unsafe AVRational this[uint i]
		{
			get
			{
				if (i >= 15)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 15)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVRational[] ToArray()
		{
			fixed (AVRational* ptr = &_0)
			{
				AVRational[] array = new AVRational[15];
				for (uint num = 0u; num < 15; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVRational[] array)
		{
			fixed (AVRational* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVRational aVRational in array)
				{
					ptr[num++] = aVRational;
					if (num >= 15)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVRational[](AVRational_array15 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct byte_array16 : IFixedArray<byte>, IFixedArray
	{
		public static readonly int Size = 16;

		private unsafe fixed byte _[16];

		public int Length => 16;

		public unsafe byte this[uint i]
		{
			get
			{
				return _[i];
			}
			set
			{
				_[i] = value;
			}
		}

		public unsafe byte[] ToArray()
		{
			byte[] array = new byte[16];
			for (uint num = 0u; num < 16; num++)
			{
				array[num] = _[num];
			}
			return array;
		}

		public unsafe void UpdateFrom(byte[] array)
		{
			uint num = 0u;
			foreach (byte b in array)
			{
				_[num++] = b;
				if (num >= 16)
				{
					break;
				}
			}
		}

		public static implicit operator byte[](byte_array16 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVRational_array25 : IFixedArray<AVRational>, IFixedArray
	{
		public static readonly int Size = 25;

		private AVRational _0;

		private AVRational _1;

		private AVRational _2;

		private AVRational _3;

		private AVRational _4;

		private AVRational _5;

		private AVRational _6;

		private AVRational _7;

		private AVRational _8;

		private AVRational _9;

		private AVRational _10;

		private AVRational _11;

		private AVRational _12;

		private AVRational _13;

		private AVRational _14;

		private AVRational _15;

		private AVRational _16;

		private AVRational _17;

		private AVRational _18;

		private AVRational _19;

		private AVRational _20;

		private AVRational _21;

		private AVRational _22;

		private AVRational _23;

		private AVRational _24;

		public int Length => 25;

		public unsafe AVRational this[uint i]
		{
			get
			{
				if (i >= 25)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 25)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVRational[] ToArray()
		{
			fixed (AVRational* ptr = &_0)
			{
				AVRational[] array = new AVRational[25];
				for (uint num = 0u; num < 25; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVRational[] array)
		{
			fixed (AVRational* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVRational aVRational in array)
				{
					ptr[num++] = aVRational;
					if (num >= 25)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVRational[](AVRational_array25 @struct)
		{
			return @struct.ToArray();
		}
	}
	public struct AVRational_array25x25 : IFixedArray<AVRational_array25>, IFixedArray
	{
		public static readonly int Size = 25;

		private AVRational_array25 _0;

		private AVRational_array25 _1;

		private AVRational_array25 _2;

		private AVRational_array25 _3;

		private AVRational_array25 _4;

		private AVRational_array25 _5;

		private AVRational_array25 _6;

		private AVRational_array25 _7;

		private AVRational_array25 _8;

		private AVRational_array25 _9;

		private AVRational_array25 _10;

		private AVRational_array25 _11;

		private AVRational_array25 _12;

		private AVRational_array25 _13;

		private AVRational_array25 _14;

		private AVRational_array25 _15;

		private AVRational_array25 _16;

		private AVRational_array25 _17;

		private AVRational_array25 _18;

		private AVRational_array25 _19;

		private AVRational_array25 _20;

		private AVRational_array25 _21;

		private AVRational_array25 _22;

		private AVRational_array25 _23;

		private AVRational_array25 _24;

		public int Length => 25;

		public unsafe AVRational_array25 this[uint i]
		{
			get
			{
				if (i >= 25)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational_array25* ptr = &_0)
				{
					return ptr[i];
				}
			}
			set
			{
				if (i >= 25)
				{
					throw new ArgumentOutOfRangeException();
				}
				fixed (AVRational_array25* ptr = &_0)
				{
					ptr[i] = value;
				}
			}
		}

		public unsafe AVRational_array25[] ToArray()
		{
			fixed (AVRational_array25* ptr = &_0)
			{
				AVRational_array25[] array = new AVRational_array25[25];
				for (uint num = 0u; num < 25; num++)
				{
					array[num] = ptr[num];
				}
				return array;
			}
		}

		public unsafe void UpdateFrom(AVRational_array25[] array)
		{
			fixed (AVRational_array25* ptr = &_0)
			{
				uint num = 0u;
				foreach (AVRational_array25 aVRational_array in array)
				{
					ptr[num++] = aVRational_array;
					if (num >= 25)
					{
						return;
					}
				}
			}
		}

		public static implicit operator AVRational_array25[](AVRational_array25x25 @struct)
		{
			return @struct.ToArray();
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void av_buffer_create_free(void* opaque, byte* data);
	public struct av_buffer_create_free_func
	{
		public IntPtr Pointer;

		public static implicit operator av_buffer_create_free_func(av_buffer_create_free func)
		{
			av_buffer_create_free_func result = default(av_buffer_create_free_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate AVBufferRef* av_buffer_pool_init_alloc(ulong size);
	public struct av_buffer_pool_init_alloc_func
	{
		public IntPtr Pointer;

		public static implicit operator av_buffer_pool_init_alloc_func(av_buffer_pool_init_alloc func)
		{
			av_buffer_pool_init_alloc_func result = default(av_buffer_pool_init_alloc_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate AVBufferRef* av_buffer_pool_init2_alloc(void* opaque, ulong size);
	public struct av_buffer_pool_init2_alloc_func
	{
		public IntPtr Pointer;

		public static implicit operator av_buffer_pool_init2_alloc_func(av_buffer_pool_init2_alloc func)
		{
			av_buffer_pool_init2_alloc_func result = default(av_buffer_pool_init2_alloc_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void av_buffer_pool_init2_pool_free(void* opaque);
	public struct av_buffer_pool_init2_pool_free_func
	{
		public IntPtr Pointer;

		public static implicit operator av_buffer_pool_init2_pool_free_func(av_buffer_pool_init2_pool_free func)
		{
			av_buffer_pool_init2_pool_free_func result = default(av_buffer_pool_init2_pool_free_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void av_log_set_callback_callback(void* p0, int p1, [MarshalAs(UnmanagedType.LPUTF8Str)] string p2, byte* p3);
	public struct av_log_set_callback_callback_func
	{
		public IntPtr Pointer;

		public static implicit operator av_log_set_callback_callback_func(av_log_set_callback_callback func)
		{
			av_log_set_callback_callback_func result = default(av_log_set_callback_callback_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int av_tree_enumerate_cmp(void* opaque, void* elem);
	public struct av_tree_enumerate_cmp_func
	{
		public IntPtr Pointer;

		public static implicit operator av_tree_enumerate_cmp_func(av_tree_enumerate_cmp func)
		{
			av_tree_enumerate_cmp_func result = default(av_tree_enumerate_cmp_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int av_tree_enumerate_enu(void* opaque, void* elem);
	public struct av_tree_enumerate_enu_func
	{
		public IntPtr Pointer;

		public static implicit operator av_tree_enumerate_enu_func(av_tree_enumerate_enu func)
		{
			av_tree_enumerate_enu_func result = default(av_tree_enumerate_enu_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int av_tree_find_cmp(void* key, void* b);
	public struct av_tree_find_cmp_func
	{
		public IntPtr Pointer;

		public static implicit operator av_tree_find_cmp_func(av_tree_find_cmp func)
		{
			av_tree_find_cmp_func result = default(av_tree_find_cmp_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int av_tree_insert_cmp(void* key, void* b);
	public struct av_tree_insert_cmp_func
	{
		public IntPtr Pointer;

		public static implicit operator av_tree_insert_cmp_func(av_tree_insert_cmp func)
		{
			av_tree_insert_cmp_func result = default(av_tree_insert_cmp_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate AVClass* AVClass_child_class_iterate(void** iter);
	public struct AVClass_child_class_iterate_func
	{
		public IntPtr Pointer;

		public static implicit operator AVClass_child_class_iterate_func(AVClass_child_class_iterate func)
		{
			AVClass_child_class_iterate_func result = default(AVClass_child_class_iterate_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void* AVClass_child_next(void* obj, void* prev);
	public struct AVClass_child_next_func
	{
		public IntPtr Pointer;

		public static implicit operator AVClass_child_next_func(AVClass_child_next func)
		{
			AVClass_child_next_func result = default(AVClass_child_next_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate AVClassCategory AVClass_get_category(void* ctx);
	public struct AVClass_get_category_func
	{
		public IntPtr Pointer;

		public static implicit operator AVClass_get_category_func(AVClass_get_category func)
		{
			AVClass_get_category_func result = default(AVClass_get_category_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate byte* AVClass_item_name(void* ctx);
	public struct AVClass_item_name_func
	{
		public IntPtr Pointer;

		public static implicit operator AVClass_item_name_func(AVClass_item_name func)
		{
			AVClass_item_name_func result = default(AVClass_item_name_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVClass_query_ranges(AVOptionRanges** p0, void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string key, int flags);
	public struct AVClass_query_ranges_func
	{
		public IntPtr Pointer;

		public static implicit operator AVClass_query_ranges_func(AVClass_query_ranges func)
		{
			AVClass_query_ranges_func result = default(AVClass_query_ranges_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int avcodec_default_execute_func(AVCodecContext* c2, void* arg2);
	public struct avcodec_default_execute_func_func
	{
		public IntPtr Pointer;

		public static implicit operator avcodec_default_execute_func_func(avcodec_default_execute_func func)
		{
			avcodec_default_execute_func_func result = default(avcodec_default_execute_func_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int avcodec_default_execute2_func(AVCodecContext* c2, void* arg2, int p2, int p3);
	public struct avcodec_default_execute2_func_func
	{
		public IntPtr Pointer;

		public static implicit operator avcodec_default_execute2_func_func(avcodec_default_execute2_func func)
		{
			avcodec_default_execute2_func_func result = default(avcodec_default_execute2_func_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void AVCodecContext_draw_horiz_band(AVCodecContext* s, AVFrame* src, ref int_array8 offset, int y, int type, int height);
	public struct AVCodecContext_draw_horiz_band_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecContext_draw_horiz_band_func(AVCodecContext_draw_horiz_band func)
		{
			AVCodecContext_draw_horiz_band_func result = default(AVCodecContext_draw_horiz_band_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVCodecContext_execute(AVCodecContext* c, func_func func, void* arg2, int* ret, int count, int size);
	public struct AVCodecContext_execute_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecContext_execute_func(AVCodecContext_execute func)
		{
			AVCodecContext_execute_func result = default(AVCodecContext_execute_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVCodecContext_execute2(AVCodecContext* c, func_func func, void* arg2, int* ret, int count);
	public struct AVCodecContext_execute2_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecContext_execute2_func(AVCodecContext_execute2 func)
		{
			AVCodecContext_execute2_func result = default(AVCodecContext_execute2_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVCodecContext_get_buffer2(AVCodecContext* s, AVFrame* frame, int flags);
	public struct AVCodecContext_get_buffer2_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecContext_get_buffer2_func(AVCodecContext_get_buffer2 func)
		{
			AVCodecContext_get_buffer2_func result = default(AVCodecContext_get_buffer2_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVCodecContext_get_encode_buffer(AVCodecContext* s, AVPacket* pkt, int flags);
	public struct AVCodecContext_get_encode_buffer_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecContext_get_encode_buffer_func(AVCodecContext_get_encode_buffer func)
		{
			AVCodecContext_get_encode_buffer_func result = default(AVCodecContext_get_encode_buffer_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate AVPixelFormat AVCodecContext_get_format(AVCodecContext* s, AVPixelFormat* fmt);
	public struct AVCodecContext_get_format_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecContext_get_format_func(AVCodecContext_get_format func)
		{
			AVCodecContext_get_format_func result = default(AVCodecContext_get_format_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void AVCodecParser_parser_close(AVCodecParserContext* s);
	public struct AVCodecParser_parser_close_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecParser_parser_close_func(AVCodecParser_parser_close func)
		{
			AVCodecParser_parser_close_func result = default(AVCodecParser_parser_close_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVCodecParser_parser_init(AVCodecParserContext* s);
	public struct AVCodecParser_parser_init_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecParser_parser_init_func(AVCodecParser_parser_init func)
		{
			AVCodecParser_parser_init_func result = default(AVCodecParser_parser_init_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVCodecParser_parser_parse(AVCodecParserContext* s, AVCodecContext* avctx, byte** poutbuf, int* poutbuf_size, byte* buf, int buf_size);
	public struct AVCodecParser_parser_parse_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecParser_parser_parse_func(AVCodecParser_parser_parse func)
		{
			AVCodecParser_parser_parse_func result = default(AVCodecParser_parser_parse_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVCodecParser_split(AVCodecContext* avctx, byte* buf, int buf_size);
	public struct AVCodecParser_split_func
	{
		public IntPtr Pointer;

		public static implicit operator AVCodecParser_split_func(AVCodecParser_split func)
		{
			AVCodecParser_split_func result = default(AVCodecParser_split_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void AVD3D11VADeviceContext_lock(void* lock_ctx);
	public struct AVD3D11VADeviceContext_lock_func
	{
		public IntPtr Pointer;

		public static implicit operator AVD3D11VADeviceContext_lock_func(AVD3D11VADeviceContext_lock func)
		{
			AVD3D11VADeviceContext_lock_func result = default(AVD3D11VADeviceContext_lock_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void AVD3D11VADeviceContext_unlock(void* lock_ctx);
	public struct AVD3D11VADeviceContext_unlock_func
	{
		public IntPtr Pointer;

		public static implicit operator AVD3D11VADeviceContext_unlock_func(AVD3D11VADeviceContext_unlock func)
		{
			AVD3D11VADeviceContext_unlock_func result = default(AVD3D11VADeviceContext_unlock_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVFilterGraph_execute(AVFilterContext* ctx, func_func func, void* arg, int* ret, int nb_jobs);
	public struct AVFilterGraph_execute_func
	{
		public IntPtr Pointer;

		public static implicit operator AVFilterGraph_execute_func(AVFilterGraph_execute func)
		{
			AVFilterGraph_execute_func result = default(AVFilterGraph_execute_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVFormatContext_control_message_cb(AVFormatContext* s, int type, void* data, ulong data_size);
	public struct AVFormatContext_control_message_cb_func
	{
		public IntPtr Pointer;

		public static implicit operator AVFormatContext_control_message_cb_func(AVFormatContext_control_message_cb func)
		{
			AVFormatContext_control_message_cb_func result = default(AVFormatContext_control_message_cb_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVFormatContext_io_close2(AVFormatContext* s, AVIOContext* pb);
	public struct AVFormatContext_io_close2_func
	{
		public IntPtr Pointer;

		public static implicit operator AVFormatContext_io_close2_func(AVFormatContext_io_close2 func)
		{
			AVFormatContext_io_close2_func result = default(AVFormatContext_io_close2_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVFormatContext_io_open(AVFormatContext* s, AVIOContext** pb, [MarshalAs(UnmanagedType.LPUTF8Str)] string url, int flags, AVDictionary** options);
	public struct AVFormatContext_io_open_func
	{
		public IntPtr Pointer;

		public static implicit operator AVFormatContext_io_open_func(AVFormatContext_io_open func)
		{
			AVFormatContext_io_open_func result = default(AVFormatContext_io_open_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void AVHWDeviceContext_free(AVHWDeviceContext* ctx);
	public struct AVHWDeviceContext_free_func
	{
		public IntPtr Pointer;

		public static implicit operator AVHWDeviceContext_free_func(AVHWDeviceContext_free func)
		{
			AVHWDeviceContext_free_func result = default(AVHWDeviceContext_free_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void AVHWFramesContext_free(AVHWFramesContext* ctx);
	public struct AVHWFramesContext_free_func
	{
		public IntPtr Pointer;

		public static implicit operator AVHWFramesContext_free_func(AVHWFramesContext_free func)
		{
			AVHWFramesContext_free_func result = default(AVHWFramesContext_free_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int avio_alloc_context_read_packet(void* opaque, byte* buf, int buf_size);
	public struct avio_alloc_context_read_packet_func
	{
		public IntPtr Pointer;

		public static implicit operator avio_alloc_context_read_packet_func(avio_alloc_context_read_packet func)
		{
			avio_alloc_context_read_packet_func result = default(avio_alloc_context_read_packet_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate long avio_alloc_context_seek(void* opaque, long offset, int whence);
	public struct avio_alloc_context_seek_func
	{
		public IntPtr Pointer;

		public static implicit operator avio_alloc_context_seek_func(avio_alloc_context_seek func)
		{
			avio_alloc_context_seek_func result = default(avio_alloc_context_seek_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int avio_alloc_context_write_packet(void* opaque, byte* buf, int buf_size);
	public struct avio_alloc_context_write_packet_func
	{
		public IntPtr Pointer;

		public static implicit operator avio_alloc_context_write_packet_func(avio_alloc_context_write_packet func)
		{
			avio_alloc_context_write_packet_func result = default(avio_alloc_context_write_packet_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVIOContext_read_packet(void* opaque, byte* buf, int buf_size);
	public struct AVIOContext_read_packet_func
	{
		public IntPtr Pointer;

		public static implicit operator AVIOContext_read_packet_func(AVIOContext_read_packet func)
		{
			AVIOContext_read_packet_func result = default(AVIOContext_read_packet_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVIOContext_read_pause(void* opaque, int pause);
	public struct AVIOContext_read_pause_func
	{
		public IntPtr Pointer;

		public static implicit operator AVIOContext_read_pause_func(AVIOContext_read_pause func)
		{
			AVIOContext_read_pause_func result = default(AVIOContext_read_pause_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate long AVIOContext_read_seek(void* opaque, int stream_index, long timestamp, int flags);
	public struct AVIOContext_read_seek_func
	{
		public IntPtr Pointer;

		public static implicit operator AVIOContext_read_seek_func(AVIOContext_read_seek func)
		{
			AVIOContext_read_seek_func result = default(AVIOContext_read_seek_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate long AVIOContext_seek(void* opaque, long offset, int whence);
	public struct AVIOContext_seek_func
	{
		public IntPtr Pointer;

		public static implicit operator AVIOContext_seek_func(AVIOContext_seek func)
		{
			AVIOContext_seek_func result = default(AVIOContext_seek_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate ulong AVIOContext_update_checksum(ulong checksum, byte* buf, uint size);
	public struct AVIOContext_update_checksum_func
	{
		public IntPtr Pointer;

		public static implicit operator AVIOContext_update_checksum_func(AVIOContext_update_checksum func)
		{
			AVIOContext_update_checksum_func result = default(AVIOContext_update_checksum_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVIOContext_write_data_type(void* opaque, byte* buf, int buf_size, AVIODataMarkerType type, long time);
	public struct AVIOContext_write_data_type_func
	{
		public IntPtr Pointer;

		public static implicit operator AVIOContext_write_data_type_func(AVIOContext_write_data_type func)
		{
			AVIOContext_write_data_type_func result = default(AVIOContext_write_data_type_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVIOContext_write_packet(void* opaque, byte* buf, int buf_size);
	public struct AVIOContext_write_packet_func
	{
		public IntPtr Pointer;

		public static implicit operator AVIOContext_write_packet_func(AVIOContext_write_packet func)
		{
			AVIOContext_write_packet_func result = default(AVIOContext_write_packet_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int AVIOInterruptCB_callback(void* p0);
	public struct AVIOInterruptCB_callback_func
	{
		public IntPtr Pointer;

		public static implicit operator AVIOInterruptCB_callback_func(AVIOInterruptCB_callback func)
		{
			AVIOInterruptCB_callback_func result = default(AVIOInterruptCB_callback_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate int func(AVFilterContext* ctx, void* arg, int jobnr, int nb_jobs);
	public struct func_func
	{
		public IntPtr Pointer;

		public static implicit operator func_func(func func)
		{
			func_func result = default(func_func);
			result.Pointer = ((func == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(func));
			return result;
		}
	}
	public static class DynamicallyLoadedBindings
	{
		public static bool ThrowErrorIfFunctionNotFound;

		public static IFunctionResolver FunctionResolver;

		public unsafe static void Initialize()
		{
			if (FunctionResolver == null)
			{
				FunctionResolver = FunctionResolverFactory.Create();
			}
			vectors.av_add_index_entry = delegate(AVStream* st, long pos, long timestamp, int size, int distance, int flags)
			{
				vectors.av_add_index_entry = FunctionResolver.GetFunctionDelegate<vectors.av_add_index_entry_delegate>("avformat", "av_add_index_entry", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_add_index_entry_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_add_index_entry(st, pos, timestamp, size, distance, flags);
			};
			vectors.av_add_q = delegate(AVRational b, AVRational c)
			{
				vectors.av_add_q = FunctionResolver.GetFunctionDelegate<vectors.av_add_q_delegate>("avutil", "av_add_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_add_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_add_q(b, c);
			};
			vectors.av_add_stable = delegate(AVRational ts_tb, long ts, AVRational inc_tb, long inc)
			{
				vectors.av_add_stable = FunctionResolver.GetFunctionDelegate<vectors.av_add_stable_delegate>("avutil", "av_add_stable", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_add_stable_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_add_stable(ts_tb, ts, inc_tb, inc);
			};
			vectors.av_append_packet = delegate(AVIOContext* s, AVPacket* pkt, int size)
			{
				vectors.av_append_packet = FunctionResolver.GetFunctionDelegate<vectors.av_append_packet_delegate>("avformat", "av_append_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_append_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_append_packet(s, pkt, size);
			};
			vectors.av_audio_fifo_alloc = delegate(AVSampleFormat sample_fmt, int channels, int nb_samples)
			{
				vectors.av_audio_fifo_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_alloc_delegate>("avutil", "av_audio_fifo_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_alloc(sample_fmt, channels, nb_samples);
			};
			vectors.av_audio_fifo_drain = delegate(AVAudioFifo* af, int nb_samples)
			{
				vectors.av_audio_fifo_drain = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_drain_delegate>("avutil", "av_audio_fifo_drain", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_drain_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_drain(af, nb_samples);
			};
			vectors.av_audio_fifo_free = delegate(AVAudioFifo* af)
			{
				vectors.av_audio_fifo_free = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_free_delegate>("avutil", "av_audio_fifo_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_audio_fifo_free(af);
			};
			vectors.av_audio_fifo_peek = delegate(AVAudioFifo* af, void** data, int nb_samples)
			{
				vectors.av_audio_fifo_peek = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_peek_delegate>("avutil", "av_audio_fifo_peek", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_peek_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_peek(af, data, nb_samples);
			};
			vectors.av_audio_fifo_peek_at = delegate(AVAudioFifo* af, void** data, int nb_samples, int offset)
			{
				vectors.av_audio_fifo_peek_at = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_peek_at_delegate>("avutil", "av_audio_fifo_peek_at", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_peek_at_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_peek_at(af, data, nb_samples, offset);
			};
			vectors.av_audio_fifo_read = delegate(AVAudioFifo* af, void** data, int nb_samples)
			{
				vectors.av_audio_fifo_read = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_read_delegate>("avutil", "av_audio_fifo_read", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_read_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_read(af, data, nb_samples);
			};
			vectors.av_audio_fifo_realloc = delegate(AVAudioFifo* af, int nb_samples)
			{
				vectors.av_audio_fifo_realloc = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_realloc_delegate>("avutil", "av_audio_fifo_realloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_realloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_realloc(af, nb_samples);
			};
			vectors.av_audio_fifo_reset = delegate(AVAudioFifo* af)
			{
				vectors.av_audio_fifo_reset = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_reset_delegate>("avutil", "av_audio_fifo_reset", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_reset_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_audio_fifo_reset(af);
			};
			vectors.av_audio_fifo_size = delegate(AVAudioFifo* af)
			{
				vectors.av_audio_fifo_size = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_size_delegate>("avutil", "av_audio_fifo_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_size(af);
			};
			vectors.av_audio_fifo_space = delegate(AVAudioFifo* af)
			{
				vectors.av_audio_fifo_space = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_space_delegate>("avutil", "av_audio_fifo_space", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_space_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_space(af);
			};
			vectors.av_audio_fifo_write = delegate(AVAudioFifo* af, void** data, int nb_samples)
			{
				vectors.av_audio_fifo_write = FunctionResolver.GetFunctionDelegate<vectors.av_audio_fifo_write_delegate>("avutil", "av_audio_fifo_write", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_audio_fifo_write_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_audio_fifo_write(af, data, nb_samples);
			};
			vectors.av_bessel_i0 = delegate(double x)
			{
				vectors.av_bessel_i0 = FunctionResolver.GetFunctionDelegate<vectors.av_bessel_i0_delegate>("avutil", "av_bessel_i0", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bessel_i0_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bessel_i0(x);
			};
			vectors.av_bsf_alloc = delegate(AVBitStreamFilter* filter, AVBSFContext** ctx)
			{
				vectors.av_bsf_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_alloc_delegate>("avcodec", "av_bsf_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_alloc(filter, ctx);
			};
			vectors.av_bsf_flush = delegate(AVBSFContext* ctx)
			{
				vectors.av_bsf_flush = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_flush_delegate>("avcodec", "av_bsf_flush", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_flush_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_bsf_flush(ctx);
			};
			vectors.av_bsf_free = delegate(AVBSFContext** ctx)
			{
				vectors.av_bsf_free = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_free_delegate>("avcodec", "av_bsf_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_bsf_free(ctx);
			};
			vectors.av_bsf_get_by_name = delegate(string name)
			{
				vectors.av_bsf_get_by_name = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_get_by_name_delegate>("avcodec", "av_bsf_get_by_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_get_by_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_get_by_name(name);
			};
			vectors.av_bsf_get_class = delegate
			{
				vectors.av_bsf_get_class = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_get_class_delegate>("avcodec", "av_bsf_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_get_class();
			};
			vectors.av_bsf_get_null_filter = delegate(AVBSFContext** bsf)
			{
				vectors.av_bsf_get_null_filter = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_get_null_filter_delegate>("avcodec", "av_bsf_get_null_filter", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_get_null_filter_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_get_null_filter(bsf);
			};
			vectors.av_bsf_init = delegate(AVBSFContext* ctx)
			{
				vectors.av_bsf_init = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_init_delegate>("avcodec", "av_bsf_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_init(ctx);
			};
			vectors.av_bsf_iterate = delegate(void** opaque)
			{
				vectors.av_bsf_iterate = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_iterate_delegate>("avcodec", "av_bsf_iterate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_iterate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_iterate(opaque);
			};
			vectors.av_bsf_list_alloc = delegate
			{
				vectors.av_bsf_list_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_list_alloc_delegate>("avcodec", "av_bsf_list_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_list_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_list_alloc();
			};
			vectors.av_bsf_list_append = delegate(AVBSFList* lst, AVBSFContext* bsf)
			{
				vectors.av_bsf_list_append = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_list_append_delegate>("avcodec", "av_bsf_list_append", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_list_append_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_list_append(lst, bsf);
			};
			vectors.av_bsf_list_append2 = delegate(AVBSFList* lst, string bsf_name, AVDictionary** options)
			{
				vectors.av_bsf_list_append2 = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_list_append2_delegate>("avcodec", "av_bsf_list_append2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_list_append2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_list_append2(lst, bsf_name, options);
			};
			vectors.av_bsf_list_finalize = delegate(AVBSFList** lst, AVBSFContext** bsf)
			{
				vectors.av_bsf_list_finalize = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_list_finalize_delegate>("avcodec", "av_bsf_list_finalize", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_list_finalize_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_list_finalize(lst, bsf);
			};
			vectors.av_bsf_list_free = delegate(AVBSFList** lst)
			{
				vectors.av_bsf_list_free = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_list_free_delegate>("avcodec", "av_bsf_list_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_list_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_bsf_list_free(lst);
			};
			vectors.av_bsf_list_parse_str = delegate(string str, AVBSFContext** bsf)
			{
				vectors.av_bsf_list_parse_str = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_list_parse_str_delegate>("avcodec", "av_bsf_list_parse_str", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_list_parse_str_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_list_parse_str(str, bsf);
			};
			vectors.av_bsf_receive_packet = delegate(AVBSFContext* ctx, AVPacket* pkt)
			{
				vectors.av_bsf_receive_packet = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_receive_packet_delegate>("avcodec", "av_bsf_receive_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_receive_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_receive_packet(ctx, pkt);
			};
			vectors.av_bsf_send_packet = delegate(AVBSFContext* ctx, AVPacket* pkt)
			{
				vectors.av_bsf_send_packet = FunctionResolver.GetFunctionDelegate<vectors.av_bsf_send_packet_delegate>("avcodec", "av_bsf_send_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_bsf_send_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_bsf_send_packet(ctx, pkt);
			};
			vectors.av_buffer_alloc = delegate(ulong size)
			{
				vectors.av_buffer_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_alloc_delegate>("avutil", "av_buffer_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_alloc(size);
			};
			vectors.av_buffer_allocz = delegate(ulong size)
			{
				vectors.av_buffer_allocz = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_allocz_delegate>("avutil", "av_buffer_allocz", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_allocz_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_allocz(size);
			};
			vectors.av_buffer_create = delegate(byte* data, ulong size, av_buffer_create_free_func free, void* opaque, int flags)
			{
				vectors.av_buffer_create = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_create_delegate>("avutil", "av_buffer_create", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_create_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_create(data, size, free, opaque, flags);
			};
			vectors.av_buffer_default_free = delegate(void* opaque, byte* data)
			{
				vectors.av_buffer_default_free = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_default_free_delegate>("avutil", "av_buffer_default_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_default_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_buffer_default_free(opaque, data);
			};
			vectors.av_buffer_get_opaque = delegate(AVBufferRef* buf)
			{
				vectors.av_buffer_get_opaque = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_get_opaque_delegate>("avutil", "av_buffer_get_opaque", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_get_opaque_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_get_opaque(buf);
			};
			vectors.av_buffer_get_ref_count = delegate(AVBufferRef* buf)
			{
				vectors.av_buffer_get_ref_count = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_get_ref_count_delegate>("avutil", "av_buffer_get_ref_count", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_get_ref_count_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_get_ref_count(buf);
			};
			vectors.av_buffer_is_writable = delegate(AVBufferRef* buf)
			{
				vectors.av_buffer_is_writable = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_is_writable_delegate>("avutil", "av_buffer_is_writable", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_is_writable_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_is_writable(buf);
			};
			vectors.av_buffer_make_writable = delegate(AVBufferRef** buf)
			{
				vectors.av_buffer_make_writable = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_make_writable_delegate>("avutil", "av_buffer_make_writable", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_make_writable_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_make_writable(buf);
			};
			vectors.av_buffer_pool_buffer_get_opaque = delegate(AVBufferRef* @ref)
			{
				vectors.av_buffer_pool_buffer_get_opaque = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_pool_buffer_get_opaque_delegate>("avutil", "av_buffer_pool_buffer_get_opaque", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_pool_buffer_get_opaque_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_pool_buffer_get_opaque(@ref);
			};
			vectors.av_buffer_pool_get = delegate(AVBufferPool* pool)
			{
				vectors.av_buffer_pool_get = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_pool_get_delegate>("avutil", "av_buffer_pool_get", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_pool_get_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_pool_get(pool);
			};
			vectors.av_buffer_pool_init = delegate(ulong size, av_buffer_pool_init_alloc_func alloc)
			{
				vectors.av_buffer_pool_init = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_pool_init_delegate>("avutil", "av_buffer_pool_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_pool_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_pool_init(size, alloc);
			};
			vectors.av_buffer_pool_init2 = delegate(ulong size, void* opaque, av_buffer_pool_init2_alloc_func alloc, av_buffer_pool_init2_pool_free_func pool_free)
			{
				vectors.av_buffer_pool_init2 = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_pool_init2_delegate>("avutil", "av_buffer_pool_init2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_pool_init2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_pool_init2(size, opaque, alloc, pool_free);
			};
			vectors.av_buffer_pool_uninit = delegate(AVBufferPool** pool)
			{
				vectors.av_buffer_pool_uninit = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_pool_uninit_delegate>("avutil", "av_buffer_pool_uninit", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_pool_uninit_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_buffer_pool_uninit(pool);
			};
			vectors.av_buffer_realloc = delegate(AVBufferRef** buf, ulong size)
			{
				vectors.av_buffer_realloc = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_realloc_delegate>("avutil", "av_buffer_realloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_realloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_realloc(buf, size);
			};
			vectors.av_buffer_ref = delegate(AVBufferRef* buf)
			{
				vectors.av_buffer_ref = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_ref_delegate>("avutil", "av_buffer_ref", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_ref_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_ref(buf);
			};
			vectors.av_buffer_replace = delegate(AVBufferRef** dst, AVBufferRef* src)
			{
				vectors.av_buffer_replace = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_replace_delegate>("avutil", "av_buffer_replace", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_replace_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffer_replace(dst, src);
			};
			vectors.av_buffer_unref = delegate(AVBufferRef** buf)
			{
				vectors.av_buffer_unref = FunctionResolver.GetFunctionDelegate<vectors.av_buffer_unref_delegate>("avutil", "av_buffer_unref", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffer_unref_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_buffer_unref(buf);
			};
			vectors.av_buffersink_get_ch_layout = delegate(AVFilterContext* ctx, AVChannelLayout* ch_layout)
			{
				vectors.av_buffersink_get_ch_layout = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_ch_layout_delegate>("avfilter", "av_buffersink_get_ch_layout", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_ch_layout_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_ch_layout(ctx, ch_layout);
			};
			vectors.av_buffersink_get_channels = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_channels = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_channels_delegate>("avfilter", "av_buffersink_get_channels", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_channels_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_channels(ctx);
			};
			vectors.av_buffersink_get_color_range = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_color_range = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_color_range_delegate>("avfilter", "av_buffersink_get_color_range", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_color_range_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_color_range(ctx);
			};
			vectors.av_buffersink_get_colorspace = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_colorspace = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_colorspace_delegate>("avfilter", "av_buffersink_get_colorspace", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_colorspace_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_colorspace(ctx);
			};
			vectors.av_buffersink_get_format = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_format = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_format_delegate>("avfilter", "av_buffersink_get_format", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_format_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_format(ctx);
			};
			vectors.av_buffersink_get_frame = delegate(AVFilterContext* ctx, AVFrame* frame)
			{
				vectors.av_buffersink_get_frame = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_frame_delegate>("avfilter", "av_buffersink_get_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_frame(ctx, frame);
			};
			vectors.av_buffersink_get_frame_flags = delegate(AVFilterContext* ctx, AVFrame* frame, int flags)
			{
				vectors.av_buffersink_get_frame_flags = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_frame_flags_delegate>("avfilter", "av_buffersink_get_frame_flags", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_frame_flags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_frame_flags(ctx, frame, flags);
			};
			vectors.av_buffersink_get_frame_rate = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_frame_rate = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_frame_rate_delegate>("avfilter", "av_buffersink_get_frame_rate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_frame_rate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_frame_rate(ctx);
			};
			vectors.av_buffersink_get_h = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_h = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_h_delegate>("avfilter", "av_buffersink_get_h", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_h_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_h(ctx);
			};
			vectors.av_buffersink_get_hw_frames_ctx = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_hw_frames_ctx = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_hw_frames_ctx_delegate>("avfilter", "av_buffersink_get_hw_frames_ctx", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_hw_frames_ctx_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_hw_frames_ctx(ctx);
			};
			vectors.av_buffersink_get_sample_aspect_ratio = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_sample_aspect_ratio = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_sample_aspect_ratio_delegate>("avfilter", "av_buffersink_get_sample_aspect_ratio", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_sample_aspect_ratio_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_sample_aspect_ratio(ctx);
			};
			vectors.av_buffersink_get_sample_rate = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_sample_rate = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_sample_rate_delegate>("avfilter", "av_buffersink_get_sample_rate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_sample_rate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_sample_rate(ctx);
			};
			vectors.av_buffersink_get_samples = delegate(AVFilterContext* ctx, AVFrame* frame, int nb_samples)
			{
				vectors.av_buffersink_get_samples = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_samples_delegate>("avfilter", "av_buffersink_get_samples", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_samples_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_samples(ctx, frame, nb_samples);
			};
			vectors.av_buffersink_get_side_data = delegate(AVFilterContext* ctx, int* nb_side_data)
			{
				vectors.av_buffersink_get_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_side_data_delegate>("avfilter", "av_buffersink_get_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_side_data(ctx, nb_side_data);
			};
			vectors.av_buffersink_get_time_base = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_time_base = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_time_base_delegate>("avfilter", "av_buffersink_get_time_base", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_time_base_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_time_base(ctx);
			};
			vectors.av_buffersink_get_type = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_type = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_type_delegate>("avfilter", "av_buffersink_get_type", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_type_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_type(ctx);
			};
			vectors.av_buffersink_get_w = delegate(AVFilterContext* ctx)
			{
				vectors.av_buffersink_get_w = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_get_w_delegate>("avfilter", "av_buffersink_get_w", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_get_w_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersink_get_w(ctx);
			};
			vectors.av_buffersink_set_frame_size = delegate(AVFilterContext* ctx, uint frame_size)
			{
				vectors.av_buffersink_set_frame_size = FunctionResolver.GetFunctionDelegate<vectors.av_buffersink_set_frame_size_delegate>("avfilter", "av_buffersink_set_frame_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersink_set_frame_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_buffersink_set_frame_size(ctx, frame_size);
			};
			vectors.av_buffersrc_add_frame = delegate(AVFilterContext* ctx, AVFrame* frame)
			{
				vectors.av_buffersrc_add_frame = FunctionResolver.GetFunctionDelegate<vectors.av_buffersrc_add_frame_delegate>("avfilter", "av_buffersrc_add_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersrc_add_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersrc_add_frame(ctx, frame);
			};
			vectors.av_buffersrc_add_frame_flags = delegate(AVFilterContext* buffer_src, AVFrame* frame, int flags)
			{
				vectors.av_buffersrc_add_frame_flags = FunctionResolver.GetFunctionDelegate<vectors.av_buffersrc_add_frame_flags_delegate>("avfilter", "av_buffersrc_add_frame_flags", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersrc_add_frame_flags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersrc_add_frame_flags(buffer_src, frame, flags);
			};
			vectors.av_buffersrc_close = delegate(AVFilterContext* ctx, long pts, uint flags)
			{
				vectors.av_buffersrc_close = FunctionResolver.GetFunctionDelegate<vectors.av_buffersrc_close_delegate>("avfilter", "av_buffersrc_close", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersrc_close_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersrc_close(ctx, pts, flags);
			};
			vectors.av_buffersrc_get_nb_failed_requests = delegate(AVFilterContext* buffer_src)
			{
				vectors.av_buffersrc_get_nb_failed_requests = FunctionResolver.GetFunctionDelegate<vectors.av_buffersrc_get_nb_failed_requests_delegate>("avfilter", "av_buffersrc_get_nb_failed_requests", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersrc_get_nb_failed_requests_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersrc_get_nb_failed_requests(buffer_src);
			};
			vectors.av_buffersrc_parameters_alloc = delegate
			{
				vectors.av_buffersrc_parameters_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_buffersrc_parameters_alloc_delegate>("avfilter", "av_buffersrc_parameters_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersrc_parameters_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersrc_parameters_alloc();
			};
			vectors.av_buffersrc_parameters_set = delegate(AVFilterContext* ctx, AVBufferSrcParameters* param)
			{
				vectors.av_buffersrc_parameters_set = FunctionResolver.GetFunctionDelegate<vectors.av_buffersrc_parameters_set_delegate>("avfilter", "av_buffersrc_parameters_set", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersrc_parameters_set_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersrc_parameters_set(ctx, param);
			};
			vectors.av_buffersrc_write_frame = delegate(AVFilterContext* ctx, AVFrame* frame)
			{
				vectors.av_buffersrc_write_frame = FunctionResolver.GetFunctionDelegate<vectors.av_buffersrc_write_frame_delegate>("avfilter", "av_buffersrc_write_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_buffersrc_write_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_buffersrc_write_frame(ctx, frame);
			};
			vectors.av_calloc = delegate(ulong nmemb, ulong size)
			{
				vectors.av_calloc = FunctionResolver.GetFunctionDelegate<vectors.av_calloc_delegate>("avutil", "av_calloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_calloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_calloc(nmemb, size);
			};
			vectors.av_channel_description = delegate(byte* buf, ulong buf_size, AVChannel channel)
			{
				vectors.av_channel_description = FunctionResolver.GetFunctionDelegate<vectors.av_channel_description_delegate>("avutil", "av_channel_description", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_description_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_description(buf, buf_size, channel);
			};
			vectors.av_channel_description_bprint = delegate(AVBPrint* bp, AVChannel channel_id)
			{
				vectors.av_channel_description_bprint = FunctionResolver.GetFunctionDelegate<vectors.av_channel_description_bprint_delegate>("avutil", "av_channel_description_bprint", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_description_bprint_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_channel_description_bprint(bp, channel_id);
			};
			vectors.av_channel_from_string = delegate(string name)
			{
				vectors.av_channel_from_string = FunctionResolver.GetFunctionDelegate<vectors.av_channel_from_string_delegate>("avutil", "av_channel_from_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_from_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_from_string(name);
			};
			vectors.av_channel_layout_ambisonic_order = delegate(AVChannelLayout* channel_layout)
			{
				vectors.av_channel_layout_ambisonic_order = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_ambisonic_order_delegate>("avutil", "av_channel_layout_ambisonic_order", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_ambisonic_order_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_ambisonic_order(channel_layout);
			};
			vectors.av_channel_layout_channel_from_index = delegate(AVChannelLayout* channel_layout, uint idx)
			{
				vectors.av_channel_layout_channel_from_index = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_channel_from_index_delegate>("avutil", "av_channel_layout_channel_from_index", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_channel_from_index_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_channel_from_index(channel_layout, idx);
			};
			vectors.av_channel_layout_channel_from_string = delegate(AVChannelLayout* channel_layout, string name)
			{
				vectors.av_channel_layout_channel_from_string = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_channel_from_string_delegate>("avutil", "av_channel_layout_channel_from_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_channel_from_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_channel_from_string(channel_layout, name);
			};
			vectors.av_channel_layout_check = delegate(AVChannelLayout* channel_layout)
			{
				vectors.av_channel_layout_check = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_check_delegate>("avutil", "av_channel_layout_check", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_check_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_check(channel_layout);
			};
			vectors.av_channel_layout_compare = delegate(AVChannelLayout* chl, AVChannelLayout* chl1)
			{
				vectors.av_channel_layout_compare = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_compare_delegate>("avutil", "av_channel_layout_compare", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_compare_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_compare(chl, chl1);
			};
			vectors.av_channel_layout_copy = delegate(AVChannelLayout* dst, AVChannelLayout* src)
			{
				vectors.av_channel_layout_copy = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_copy_delegate>("avutil", "av_channel_layout_copy", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_copy_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_copy(dst, src);
			};
			vectors.av_channel_layout_custom_init = delegate(AVChannelLayout* channel_layout, int nb_channels)
			{
				vectors.av_channel_layout_custom_init = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_custom_init_delegate>("avutil", "av_channel_layout_custom_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_custom_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_custom_init(channel_layout, nb_channels);
			};
			vectors.av_channel_layout_default = delegate(AVChannelLayout* ch_layout, int nb_channels)
			{
				vectors.av_channel_layout_default = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_default_delegate>("avutil", "av_channel_layout_default", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_default_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_channel_layout_default(ch_layout, nb_channels);
			};
			vectors.av_channel_layout_describe = delegate(AVChannelLayout* channel_layout, byte* buf, ulong buf_size)
			{
				vectors.av_channel_layout_describe = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_describe_delegate>("avutil", "av_channel_layout_describe", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_describe_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_describe(channel_layout, buf, buf_size);
			};
			vectors.av_channel_layout_describe_bprint = delegate(AVChannelLayout* channel_layout, AVBPrint* bp)
			{
				vectors.av_channel_layout_describe_bprint = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_describe_bprint_delegate>("avutil", "av_channel_layout_describe_bprint", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_describe_bprint_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_describe_bprint(channel_layout, bp);
			};
			vectors.av_channel_layout_from_mask = delegate(AVChannelLayout* channel_layout, ulong mask)
			{
				vectors.av_channel_layout_from_mask = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_from_mask_delegate>("avutil", "av_channel_layout_from_mask", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_from_mask_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_from_mask(channel_layout, mask);
			};
			vectors.av_channel_layout_from_string = delegate(AVChannelLayout* channel_layout, string str)
			{
				vectors.av_channel_layout_from_string = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_from_string_delegate>("avutil", "av_channel_layout_from_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_from_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_from_string(channel_layout, str);
			};
			vectors.av_channel_layout_index_from_channel = delegate(AVChannelLayout* channel_layout, AVChannel channel)
			{
				vectors.av_channel_layout_index_from_channel = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_index_from_channel_delegate>("avutil", "av_channel_layout_index_from_channel", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_index_from_channel_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_index_from_channel(channel_layout, channel);
			};
			vectors.av_channel_layout_index_from_string = delegate(AVChannelLayout* channel_layout, string name)
			{
				vectors.av_channel_layout_index_from_string = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_index_from_string_delegate>("avutil", "av_channel_layout_index_from_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_index_from_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_index_from_string(channel_layout, name);
			};
			vectors.av_channel_layout_retype = delegate(AVChannelLayout* channel_layout, AVChannelOrder order, int flags)
			{
				vectors.av_channel_layout_retype = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_retype_delegate>("avutil", "av_channel_layout_retype", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_retype_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_retype(channel_layout, order, flags);
			};
			vectors.av_channel_layout_standard = delegate(void** opaque)
			{
				vectors.av_channel_layout_standard = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_standard_delegate>("avutil", "av_channel_layout_standard", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_standard_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_standard(opaque);
			};
			vectors.av_channel_layout_subset = delegate(AVChannelLayout* channel_layout, ulong mask)
			{
				vectors.av_channel_layout_subset = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_subset_delegate>("avutil", "av_channel_layout_subset", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_subset_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_layout_subset(channel_layout, mask);
			};
			vectors.av_channel_layout_uninit = delegate(AVChannelLayout* channel_layout)
			{
				vectors.av_channel_layout_uninit = FunctionResolver.GetFunctionDelegate<vectors.av_channel_layout_uninit_delegate>("avutil", "av_channel_layout_uninit", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_layout_uninit_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_channel_layout_uninit(channel_layout);
			};
			vectors.av_channel_name = delegate(byte* buf, ulong buf_size, AVChannel channel)
			{
				vectors.av_channel_name = FunctionResolver.GetFunctionDelegate<vectors.av_channel_name_delegate>("avutil", "av_channel_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_channel_name(buf, buf_size, channel);
			};
			vectors.av_channel_name_bprint = delegate(AVBPrint* bp, AVChannel channel_id)
			{
				vectors.av_channel_name_bprint = FunctionResolver.GetFunctionDelegate<vectors.av_channel_name_bprint_delegate>("avutil", "av_channel_name_bprint", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_channel_name_bprint_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_channel_name_bprint(bp, channel_id);
			};
			vectors.av_chroma_location_enum_to_pos = delegate(int* xpos, int* ypos, AVChromaLocation pos)
			{
				vectors.av_chroma_location_enum_to_pos = FunctionResolver.GetFunctionDelegate<vectors.av_chroma_location_enum_to_pos_delegate>("avutil", "av_chroma_location_enum_to_pos", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_chroma_location_enum_to_pos_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_chroma_location_enum_to_pos(xpos, ypos, pos);
			};
			vectors.av_chroma_location_from_name = delegate(string name)
			{
				vectors.av_chroma_location_from_name = FunctionResolver.GetFunctionDelegate<vectors.av_chroma_location_from_name_delegate>("avutil", "av_chroma_location_from_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_chroma_location_from_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_chroma_location_from_name(name);
			};
			vectors.av_chroma_location_name = delegate(AVChromaLocation location)
			{
				vectors.av_chroma_location_name = FunctionResolver.GetFunctionDelegate<vectors.av_chroma_location_name_delegate>("avutil", "av_chroma_location_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_chroma_location_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_chroma_location_name(location);
			};
			vectors.av_chroma_location_pos_to_enum = delegate(int xpos, int ypos)
			{
				vectors.av_chroma_location_pos_to_enum = FunctionResolver.GetFunctionDelegate<vectors.av_chroma_location_pos_to_enum_delegate>("avutil", "av_chroma_location_pos_to_enum", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_chroma_location_pos_to_enum_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_chroma_location_pos_to_enum(xpos, ypos);
			};
			vectors.av_codec_get_id = delegate(AVCodecTag** tags, uint tag)
			{
				vectors.av_codec_get_id = FunctionResolver.GetFunctionDelegate<vectors.av_codec_get_id_delegate>("avformat", "av_codec_get_id", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_codec_get_id_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_codec_get_id(tags, tag);
			};
			vectors.av_codec_get_tag = delegate(AVCodecTag** tags, AVCodecID id)
			{
				vectors.av_codec_get_tag = FunctionResolver.GetFunctionDelegate<vectors.av_codec_get_tag_delegate>("avformat", "av_codec_get_tag", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_codec_get_tag_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_codec_get_tag(tags, id);
			};
			vectors.av_codec_get_tag2 = delegate(AVCodecTag** tags, AVCodecID id, uint* tag)
			{
				vectors.av_codec_get_tag2 = FunctionResolver.GetFunctionDelegate<vectors.av_codec_get_tag2_delegate>("avformat", "av_codec_get_tag2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_codec_get_tag2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_codec_get_tag2(tags, id, tag);
			};
			vectors.av_codec_is_decoder = delegate(AVCodec* codec)
			{
				vectors.av_codec_is_decoder = FunctionResolver.GetFunctionDelegate<vectors.av_codec_is_decoder_delegate>("avcodec", "av_codec_is_decoder", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_codec_is_decoder_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_codec_is_decoder(codec);
			};
			vectors.av_codec_is_encoder = delegate(AVCodec* codec)
			{
				vectors.av_codec_is_encoder = FunctionResolver.GetFunctionDelegate<vectors.av_codec_is_encoder_delegate>("avcodec", "av_codec_is_encoder", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_codec_is_encoder_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_codec_is_encoder(codec);
			};
			vectors.av_codec_iterate = delegate(void** opaque)
			{
				vectors.av_codec_iterate = FunctionResolver.GetFunctionDelegate<vectors.av_codec_iterate_delegate>("avcodec", "av_codec_iterate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_codec_iterate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_codec_iterate(opaque);
			};
			vectors.av_color_primaries_from_name = delegate(string name)
			{
				vectors.av_color_primaries_from_name = FunctionResolver.GetFunctionDelegate<vectors.av_color_primaries_from_name_delegate>("avutil", "av_color_primaries_from_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_color_primaries_from_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_color_primaries_from_name(name);
			};
			vectors.av_color_primaries_name = delegate(AVColorPrimaries primaries)
			{
				vectors.av_color_primaries_name = FunctionResolver.GetFunctionDelegate<vectors.av_color_primaries_name_delegate>("avutil", "av_color_primaries_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_color_primaries_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_color_primaries_name(primaries);
			};
			vectors.av_color_range_from_name = delegate(string name)
			{
				vectors.av_color_range_from_name = FunctionResolver.GetFunctionDelegate<vectors.av_color_range_from_name_delegate>("avutil", "av_color_range_from_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_color_range_from_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_color_range_from_name(name);
			};
			vectors.av_color_range_name = delegate(AVColorRange range)
			{
				vectors.av_color_range_name = FunctionResolver.GetFunctionDelegate<vectors.av_color_range_name_delegate>("avutil", "av_color_range_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_color_range_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_color_range_name(range);
			};
			vectors.av_color_space_from_name = delegate(string name)
			{
				vectors.av_color_space_from_name = FunctionResolver.GetFunctionDelegate<vectors.av_color_space_from_name_delegate>("avutil", "av_color_space_from_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_color_space_from_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_color_space_from_name(name);
			};
			vectors.av_color_space_name = delegate(AVColorSpace space)
			{
				vectors.av_color_space_name = FunctionResolver.GetFunctionDelegate<vectors.av_color_space_name_delegate>("avutil", "av_color_space_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_color_space_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_color_space_name(space);
			};
			vectors.av_color_transfer_from_name = delegate(string name)
			{
				vectors.av_color_transfer_from_name = FunctionResolver.GetFunctionDelegate<vectors.av_color_transfer_from_name_delegate>("avutil", "av_color_transfer_from_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_color_transfer_from_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_color_transfer_from_name(name);
			};
			vectors.av_color_transfer_name = delegate(AVColorTransferCharacteristic transfer)
			{
				vectors.av_color_transfer_name = FunctionResolver.GetFunctionDelegate<vectors.av_color_transfer_name_delegate>("avutil", "av_color_transfer_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_color_transfer_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_color_transfer_name(transfer);
			};
			vectors.av_compare_mod = delegate(ulong a, ulong b, ulong mod)
			{
				vectors.av_compare_mod = FunctionResolver.GetFunctionDelegate<vectors.av_compare_mod_delegate>("avutil", "av_compare_mod", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_compare_mod_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_compare_mod(a, b, mod);
			};
			vectors.av_compare_ts = delegate(long ts_a, AVRational tb_a, long ts_b, AVRational tb_b)
			{
				vectors.av_compare_ts = FunctionResolver.GetFunctionDelegate<vectors.av_compare_ts_delegate>("avutil", "av_compare_ts", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_compare_ts_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_compare_ts(ts_a, tb_a, ts_b, tb_b);
			};
			vectors.av_container_fifo_alloc_avpacket = delegate(uint flags)
			{
				vectors.av_container_fifo_alloc_avpacket = FunctionResolver.GetFunctionDelegate<vectors.av_container_fifo_alloc_avpacket_delegate>("avcodec", "av_container_fifo_alloc_avpacket", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_container_fifo_alloc_avpacket_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_container_fifo_alloc_avpacket(flags);
			};
			vectors.av_content_light_metadata_alloc = delegate(ulong* size)
			{
				vectors.av_content_light_metadata_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_content_light_metadata_alloc_delegate>("avutil", "av_content_light_metadata_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_content_light_metadata_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_content_light_metadata_alloc(size);
			};
			vectors.av_content_light_metadata_create_side_data = delegate(AVFrame* frame)
			{
				vectors.av_content_light_metadata_create_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_content_light_metadata_create_side_data_delegate>("avutil", "av_content_light_metadata_create_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_content_light_metadata_create_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_content_light_metadata_create_side_data(frame);
			};
			vectors.av_cpb_properties_alloc = delegate(ulong* size)
			{
				vectors.av_cpb_properties_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_cpb_properties_alloc_delegate>("avcodec", "av_cpb_properties_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_cpb_properties_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_cpb_properties_alloc(size);
			};
			vectors.av_cpu_count = delegate
			{
				vectors.av_cpu_count = FunctionResolver.GetFunctionDelegate<vectors.av_cpu_count_delegate>("avutil", "av_cpu_count", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_cpu_count_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_cpu_count();
			};
			vectors.av_cpu_force_count = delegate(int count)
			{
				vectors.av_cpu_force_count = FunctionResolver.GetFunctionDelegate<vectors.av_cpu_force_count_delegate>("avutil", "av_cpu_force_count", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_cpu_force_count_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_cpu_force_count(count);
			};
			vectors.av_cpu_max_align = delegate
			{
				vectors.av_cpu_max_align = FunctionResolver.GetFunctionDelegate<vectors.av_cpu_max_align_delegate>("avutil", "av_cpu_max_align", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_cpu_max_align_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_cpu_max_align();
			};
			vectors.av_d2q = delegate(double d, int max)
			{
				vectors.av_d2q = FunctionResolver.GetFunctionDelegate<vectors.av_d2q_delegate>("avutil", "av_d2q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_d2q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_d2q(d, max);
			};
			vectors.av_d3d11va_alloc_context = delegate
			{
				vectors.av_d3d11va_alloc_context = FunctionResolver.GetFunctionDelegate<vectors.av_d3d11va_alloc_context_delegate>("avcodec", "av_d3d11va_alloc_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_d3d11va_alloc_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_d3d11va_alloc_context();
			};
			vectors.av_default_get_category = delegate(void* ptr)
			{
				vectors.av_default_get_category = FunctionResolver.GetFunctionDelegate<vectors.av_default_get_category_delegate>("avutil", "av_default_get_category", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_default_get_category_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_default_get_category(ptr);
			};
			vectors.av_default_item_name = delegate(void* ctx)
			{
				vectors.av_default_item_name = FunctionResolver.GetFunctionDelegate<vectors.av_default_item_name_delegate>("avutil", "av_default_item_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_default_item_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_default_item_name(ctx);
			};
			vectors.av_demuxer_iterate = delegate(void** opaque)
			{
				vectors.av_demuxer_iterate = FunctionResolver.GetFunctionDelegate<vectors.av_demuxer_iterate_delegate>("avformat", "av_demuxer_iterate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_demuxer_iterate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_demuxer_iterate(opaque);
			};
			vectors.av_dict_copy = delegate(AVDictionary** dst, AVDictionary* src, int flags)
			{
				vectors.av_dict_copy = FunctionResolver.GetFunctionDelegate<vectors.av_dict_copy_delegate>("avutil", "av_dict_copy", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_copy_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dict_copy(dst, src, flags);
			};
			vectors.av_dict_count = delegate(AVDictionary* m)
			{
				vectors.av_dict_count = FunctionResolver.GetFunctionDelegate<vectors.av_dict_count_delegate>("avutil", "av_dict_count", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_count_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dict_count(m);
			};
			vectors.av_dict_free = delegate(AVDictionary** m)
			{
				vectors.av_dict_free = FunctionResolver.GetFunctionDelegate<vectors.av_dict_free_delegate>("avutil", "av_dict_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_dict_free(m);
			};
			vectors.av_dict_get = delegate(AVDictionary* m, string key, AVDictionaryEntry* prev, int flags)
			{
				vectors.av_dict_get = FunctionResolver.GetFunctionDelegate<vectors.av_dict_get_delegate>("avutil", "av_dict_get", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_get_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dict_get(m, key, prev, flags);
			};
			vectors.av_dict_get_string = delegate(AVDictionary* m, byte** buffer, byte key_val_sep, byte pairs_sep)
			{
				vectors.av_dict_get_string = FunctionResolver.GetFunctionDelegate<vectors.av_dict_get_string_delegate>("avutil", "av_dict_get_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_get_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dict_get_string(m, buffer, key_val_sep, pairs_sep);
			};
			vectors.av_dict_iterate = delegate(AVDictionary* m, AVDictionaryEntry* prev)
			{
				vectors.av_dict_iterate = FunctionResolver.GetFunctionDelegate<vectors.av_dict_iterate_delegate>("avutil", "av_dict_iterate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_iterate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dict_iterate(m, prev);
			};
			vectors.av_dict_parse_string = delegate(AVDictionary** pm, string str, string key_val_sep, string pairs_sep, int flags)
			{
				vectors.av_dict_parse_string = FunctionResolver.GetFunctionDelegate<vectors.av_dict_parse_string_delegate>("avutil", "av_dict_parse_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_parse_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dict_parse_string(pm, str, key_val_sep, pairs_sep, flags);
			};
			vectors.av_dict_set = delegate(AVDictionary** pm, string key, string value, int flags)
			{
				vectors.av_dict_set = FunctionResolver.GetFunctionDelegate<vectors.av_dict_set_delegate>("avutil", "av_dict_set", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_set_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dict_set(pm, key, value, flags);
			};
			vectors.av_dict_set_int = delegate(AVDictionary** pm, string key, long value, int flags)
			{
				vectors.av_dict_set_int = FunctionResolver.GetFunctionDelegate<vectors.av_dict_set_int_delegate>("avutil", "av_dict_set_int", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dict_set_int_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dict_set_int(pm, key, value, flags);
			};
			vectors.av_display_matrix_flip = delegate(ref int_array9 matrix, int hflip, int vflip)
			{
				vectors.av_display_matrix_flip = FunctionResolver.GetFunctionDelegate<vectors.av_display_matrix_flip_delegate>("avutil", "av_display_matrix_flip", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_display_matrix_flip_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_display_matrix_flip(ref matrix, hflip, vflip);
			};
			vectors.av_display_rotation_get = delegate(in int_array9 matrix)
			{
				vectors.av_display_rotation_get = FunctionResolver.GetFunctionDelegate<vectors.av_display_rotation_get_delegate>("avutil", "av_display_rotation_get", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_display_rotation_get_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_display_rotation_get(in matrix);
			};
			vectors.av_display_rotation_set = delegate(ref int_array9 matrix, double angle)
			{
				vectors.av_display_rotation_set = FunctionResolver.GetFunctionDelegate<vectors.av_display_rotation_set_delegate>("avutil", "av_display_rotation_set", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_display_rotation_set_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_display_rotation_set(ref matrix, angle);
			};
			vectors.av_disposition_from_string = delegate(string disp)
			{
				vectors.av_disposition_from_string = FunctionResolver.GetFunctionDelegate<vectors.av_disposition_from_string_delegate>("avformat", "av_disposition_from_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_disposition_from_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_disposition_from_string(disp);
			};
			vectors.av_disposition_to_string = delegate(int disposition)
			{
				vectors.av_disposition_to_string = FunctionResolver.GetFunctionDelegate<vectors.av_disposition_to_string_delegate>("avformat", "av_disposition_to_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_disposition_to_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_disposition_to_string(disposition);
			};
			vectors.av_div_q = delegate(AVRational b, AVRational c)
			{
				vectors.av_div_q = FunctionResolver.GetFunctionDelegate<vectors.av_div_q_delegate>("avutil", "av_div_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_div_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_div_q(b, c);
			};
			vectors.av_dump_format = delegate(AVFormatContext* ic, int index, string url, int is_output)
			{
				vectors.av_dump_format = FunctionResolver.GetFunctionDelegate<vectors.av_dump_format_delegate>("avformat", "av_dump_format", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dump_format_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_dump_format(ic, index, url, is_output);
			};
			vectors.av_dynamic_hdr_plus_alloc = delegate(ulong* size)
			{
				vectors.av_dynamic_hdr_plus_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_dynamic_hdr_plus_alloc_delegate>("avutil", "av_dynamic_hdr_plus_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dynamic_hdr_plus_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dynamic_hdr_plus_alloc(size);
			};
			vectors.av_dynamic_hdr_plus_create_side_data = delegate(AVFrame* frame)
			{
				vectors.av_dynamic_hdr_plus_create_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_dynamic_hdr_plus_create_side_data_delegate>("avutil", "av_dynamic_hdr_plus_create_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dynamic_hdr_plus_create_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dynamic_hdr_plus_create_side_data(frame);
			};
			vectors.av_dynamic_hdr_plus_from_t35 = delegate(AVDynamicHDRPlus* s, byte* data, ulong size)
			{
				vectors.av_dynamic_hdr_plus_from_t35 = FunctionResolver.GetFunctionDelegate<vectors.av_dynamic_hdr_plus_from_t35_delegate>("avutil", "av_dynamic_hdr_plus_from_t35", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dynamic_hdr_plus_from_t35_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dynamic_hdr_plus_from_t35(s, data, size);
			};
			vectors.av_dynamic_hdr_plus_to_t35 = delegate(AVDynamicHDRPlus* s, byte** data, ulong* size)
			{
				vectors.av_dynamic_hdr_plus_to_t35 = FunctionResolver.GetFunctionDelegate<vectors.av_dynamic_hdr_plus_to_t35_delegate>("avutil", "av_dynamic_hdr_plus_to_t35", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dynamic_hdr_plus_to_t35_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dynamic_hdr_plus_to_t35(s, data, size);
			};
			vectors.av_dynarray_add = delegate(void* tab_ptr, int* nb_ptr, void* elem)
			{
				vectors.av_dynarray_add = FunctionResolver.GetFunctionDelegate<vectors.av_dynarray_add_delegate>("avutil", "av_dynarray_add", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dynarray_add_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_dynarray_add(tab_ptr, nb_ptr, elem);
			};
			vectors.av_dynarray_add_nofree = delegate(void* tab_ptr, int* nb_ptr, void* elem)
			{
				vectors.av_dynarray_add_nofree = FunctionResolver.GetFunctionDelegate<vectors.av_dynarray_add_nofree_delegate>("avutil", "av_dynarray_add_nofree", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dynarray_add_nofree_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dynarray_add_nofree(tab_ptr, nb_ptr, elem);
			};
			vectors.av_dynarray2_add = delegate(void** tab_ptr, int* nb_ptr, ulong elem_size, byte* elem_data)
			{
				vectors.av_dynarray2_add = FunctionResolver.GetFunctionDelegate<vectors.av_dynarray2_add_delegate>("avutil", "av_dynarray2_add", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_dynarray2_add_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_dynarray2_add(tab_ptr, nb_ptr, elem_size, elem_data);
			};
			vectors.av_fast_malloc = delegate(void* ptr, uint* size, ulong min_size)
			{
				vectors.av_fast_malloc = FunctionResolver.GetFunctionDelegate<vectors.av_fast_malloc_delegate>("avutil", "av_fast_malloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_fast_malloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_fast_malloc(ptr, size, min_size);
			};
			vectors.av_fast_mallocz = delegate(void* ptr, uint* size, ulong min_size)
			{
				vectors.av_fast_mallocz = FunctionResolver.GetFunctionDelegate<vectors.av_fast_mallocz_delegate>("avutil", "av_fast_mallocz", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_fast_mallocz_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_fast_mallocz(ptr, size, min_size);
			};
			vectors.av_fast_padded_malloc = delegate(void* ptr, uint* size, ulong min_size)
			{
				vectors.av_fast_padded_malloc = FunctionResolver.GetFunctionDelegate<vectors.av_fast_padded_malloc_delegate>("avcodec", "av_fast_padded_malloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_fast_padded_malloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_fast_padded_malloc(ptr, size, min_size);
			};
			vectors.av_fast_padded_mallocz = delegate(void* ptr, uint* size, ulong min_size)
			{
				vectors.av_fast_padded_mallocz = FunctionResolver.GetFunctionDelegate<vectors.av_fast_padded_mallocz_delegate>("avcodec", "av_fast_padded_mallocz", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_fast_padded_mallocz_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_fast_padded_mallocz(ptr, size, min_size);
			};
			vectors.av_fast_realloc = delegate(void* ptr, uint* size, ulong min_size)
			{
				vectors.av_fast_realloc = FunctionResolver.GetFunctionDelegate<vectors.av_fast_realloc_delegate>("avutil", "av_fast_realloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_fast_realloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_fast_realloc(ptr, size, min_size);
			};
			vectors.av_file_map = delegate(string filename, byte** bufptr, ulong* size, int log_offset, void* log_ctx)
			{
				vectors.av_file_map = FunctionResolver.GetFunctionDelegate<vectors.av_file_map_delegate>("avutil", "av_file_map", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_file_map_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_file_map(filename, bufptr, size, log_offset, log_ctx);
			};
			vectors.av_file_unmap = delegate(byte* bufptr, ulong size)
			{
				vectors.av_file_unmap = FunctionResolver.GetFunctionDelegate<vectors.av_file_unmap_delegate>("avutil", "av_file_unmap", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_file_unmap_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_file_unmap(bufptr, size);
			};
			vectors.av_filename_number_test = delegate(string filename)
			{
				vectors.av_filename_number_test = FunctionResolver.GetFunctionDelegate<vectors.av_filename_number_test_delegate>("avformat", "av_filename_number_test", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_filename_number_test_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_filename_number_test(filename);
			};
			vectors.av_filter_iterate = delegate(void** opaque)
			{
				vectors.av_filter_iterate = FunctionResolver.GetFunctionDelegate<vectors.av_filter_iterate_delegate>("avfilter", "av_filter_iterate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_filter_iterate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_filter_iterate(opaque);
			};
			vectors.av_find_best_pix_fmt_of_2 = delegate(AVPixelFormat dst_pix_fmt1, AVPixelFormat dst_pix_fmt2, AVPixelFormat src_pix_fmt, int has_alpha, int* loss_ptr)
			{
				vectors.av_find_best_pix_fmt_of_2 = FunctionResolver.GetFunctionDelegate<vectors.av_find_best_pix_fmt_of_2_delegate>("avutil", "av_find_best_pix_fmt_of_2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_find_best_pix_fmt_of_2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_find_best_pix_fmt_of_2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, has_alpha, loss_ptr);
			};
			vectors.av_find_best_stream = delegate(AVFormatContext* ic, AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec** decoder_ret, int flags)
			{
				vectors.av_find_best_stream = FunctionResolver.GetFunctionDelegate<vectors.av_find_best_stream_delegate>("avformat", "av_find_best_stream", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_find_best_stream_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_find_best_stream(ic, type, wanted_stream_nb, related_stream, decoder_ret, flags);
			};
			vectors.av_find_default_stream_index = delegate(AVFormatContext* s)
			{
				vectors.av_find_default_stream_index = FunctionResolver.GetFunctionDelegate<vectors.av_find_default_stream_index_delegate>("avformat", "av_find_default_stream_index", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_find_default_stream_index_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_find_default_stream_index(s);
			};
			vectors.av_find_input_format = delegate(string short_name)
			{
				vectors.av_find_input_format = FunctionResolver.GetFunctionDelegate<vectors.av_find_input_format_delegate>("avformat", "av_find_input_format", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_find_input_format_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_find_input_format(short_name);
			};
			vectors.av_find_nearest_q_idx = delegate(AVRational q, AVRational* q_list)
			{
				vectors.av_find_nearest_q_idx = FunctionResolver.GetFunctionDelegate<vectors.av_find_nearest_q_idx_delegate>("avutil", "av_find_nearest_q_idx", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_find_nearest_q_idx_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_find_nearest_q_idx(q, q_list);
			};
			vectors.av_find_program_from_stream = delegate(AVFormatContext* ic, AVProgram* last, int s)
			{
				vectors.av_find_program_from_stream = FunctionResolver.GetFunctionDelegate<vectors.av_find_program_from_stream_delegate>("avformat", "av_find_program_from_stream", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_find_program_from_stream_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_find_program_from_stream(ic, last, s);
			};
			vectors.av_force_cpu_flags = delegate(int flags)
			{
				vectors.av_force_cpu_flags = FunctionResolver.GetFunctionDelegate<vectors.av_force_cpu_flags_delegate>("avutil", "av_force_cpu_flags", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_force_cpu_flags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_force_cpu_flags(flags);
			};
			vectors.av_fourcc_make_string = delegate(byte* buf, uint fourcc)
			{
				vectors.av_fourcc_make_string = FunctionResolver.GetFunctionDelegate<vectors.av_fourcc_make_string_delegate>("avutil", "av_fourcc_make_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_fourcc_make_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_fourcc_make_string(buf, fourcc);
			};
			vectors.av_frame_alloc = delegate
			{
				vectors.av_frame_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_frame_alloc_delegate>("avutil", "av_frame_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_alloc();
			};
			vectors.av_frame_apply_cropping = delegate(AVFrame* frame, int flags)
			{
				vectors.av_frame_apply_cropping = FunctionResolver.GetFunctionDelegate<vectors.av_frame_apply_cropping_delegate>("avutil", "av_frame_apply_cropping", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_apply_cropping_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_apply_cropping(frame, flags);
			};
			vectors.av_frame_clone = delegate(AVFrame* src)
			{
				vectors.av_frame_clone = FunctionResolver.GetFunctionDelegate<vectors.av_frame_clone_delegate>("avutil", "av_frame_clone", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_clone_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_clone(src);
			};
			vectors.av_frame_copy = delegate(AVFrame* dst, AVFrame* src)
			{
				vectors.av_frame_copy = FunctionResolver.GetFunctionDelegate<vectors.av_frame_copy_delegate>("avutil", "av_frame_copy", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_copy_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_copy(dst, src);
			};
			vectors.av_frame_copy_props = delegate(AVFrame* dst, AVFrame* src)
			{
				vectors.av_frame_copy_props = FunctionResolver.GetFunctionDelegate<vectors.av_frame_copy_props_delegate>("avutil", "av_frame_copy_props", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_copy_props_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_copy_props(dst, src);
			};
			vectors.av_frame_free = delegate(AVFrame** frame)
			{
				vectors.av_frame_free = FunctionResolver.GetFunctionDelegate<vectors.av_frame_free_delegate>("avutil", "av_frame_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_frame_free(frame);
			};
			vectors.av_frame_get_buffer = delegate(AVFrame* frame, int align)
			{
				vectors.av_frame_get_buffer = FunctionResolver.GetFunctionDelegate<vectors.av_frame_get_buffer_delegate>("avutil", "av_frame_get_buffer", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_get_buffer_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_get_buffer(frame, align);
			};
			vectors.av_frame_get_plane_buffer = delegate(AVFrame* frame, int plane)
			{
				vectors.av_frame_get_plane_buffer = FunctionResolver.GetFunctionDelegate<vectors.av_frame_get_plane_buffer_delegate>("avutil", "av_frame_get_plane_buffer", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_get_plane_buffer_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_get_plane_buffer(frame, plane);
			};
			vectors.av_frame_get_side_data = delegate(AVFrame* frame, AVFrameSideDataType type)
			{
				vectors.av_frame_get_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_frame_get_side_data_delegate>("avutil", "av_frame_get_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_get_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_get_side_data(frame, type);
			};
			vectors.av_frame_is_writable = delegate(AVFrame* frame)
			{
				vectors.av_frame_is_writable = FunctionResolver.GetFunctionDelegate<vectors.av_frame_is_writable_delegate>("avutil", "av_frame_is_writable", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_is_writable_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_is_writable(frame);
			};
			vectors.av_frame_make_writable = delegate(AVFrame* frame)
			{
				vectors.av_frame_make_writable = FunctionResolver.GetFunctionDelegate<vectors.av_frame_make_writable_delegate>("avutil", "av_frame_make_writable", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_make_writable_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_make_writable(frame);
			};
			vectors.av_frame_move_ref = delegate(AVFrame* dst, AVFrame* src)
			{
				vectors.av_frame_move_ref = FunctionResolver.GetFunctionDelegate<vectors.av_frame_move_ref_delegate>("avutil", "av_frame_move_ref", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_move_ref_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_frame_move_ref(dst, src);
			};
			vectors.av_frame_new_side_data = delegate(AVFrame* frame, AVFrameSideDataType type, ulong size)
			{
				vectors.av_frame_new_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_frame_new_side_data_delegate>("avutil", "av_frame_new_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_new_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_new_side_data(frame, type, size);
			};
			vectors.av_frame_new_side_data_from_buf = delegate(AVFrame* frame, AVFrameSideDataType type, AVBufferRef* buf)
			{
				vectors.av_frame_new_side_data_from_buf = FunctionResolver.GetFunctionDelegate<vectors.av_frame_new_side_data_from_buf_delegate>("avutil", "av_frame_new_side_data_from_buf", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_new_side_data_from_buf_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_new_side_data_from_buf(frame, type, buf);
			};
			vectors.av_frame_ref = delegate(AVFrame* dst, AVFrame* src)
			{
				vectors.av_frame_ref = FunctionResolver.GetFunctionDelegate<vectors.av_frame_ref_delegate>("avutil", "av_frame_ref", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_ref_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_ref(dst, src);
			};
			vectors.av_frame_remove_side_data = delegate(AVFrame* frame, AVFrameSideDataType type)
			{
				vectors.av_frame_remove_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_frame_remove_side_data_delegate>("avutil", "av_frame_remove_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_remove_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_frame_remove_side_data(frame, type);
			};
			vectors.av_frame_replace = delegate(AVFrame* dst, AVFrame* src)
			{
				vectors.av_frame_replace = FunctionResolver.GetFunctionDelegate<vectors.av_frame_replace_delegate>("avutil", "av_frame_replace", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_replace_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_replace(dst, src);
			};
			vectors.av_frame_side_data_add = delegate(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type, AVBufferRef** buf, uint flags)
			{
				vectors.av_frame_side_data_add = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_add_delegate>("avutil", "av_frame_side_data_add", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_add_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_side_data_add(sd, nb_sd, type, buf, flags);
			};
			vectors.av_frame_side_data_clone = delegate(AVFrameSideData*** sd, int* nb_sd, AVFrameSideData* src, uint flags)
			{
				vectors.av_frame_side_data_clone = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_clone_delegate>("avutil", "av_frame_side_data_clone", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_clone_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_side_data_clone(sd, nb_sd, src, flags);
			};
			vectors.av_frame_side_data_desc = delegate(AVFrameSideDataType type)
			{
				vectors.av_frame_side_data_desc = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_desc_delegate>("avutil", "av_frame_side_data_desc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_desc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_side_data_desc(type);
			};
			vectors.av_frame_side_data_free = delegate(AVFrameSideData*** sd, int* nb_sd)
			{
				vectors.av_frame_side_data_free = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_free_delegate>("avutil", "av_frame_side_data_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_frame_side_data_free(sd, nb_sd);
			};
			vectors.av_frame_side_data_get_c = delegate(AVFrameSideData** sd, int nb_sd, AVFrameSideDataType type)
			{
				vectors.av_frame_side_data_get_c = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_get_c_delegate>("avutil", "av_frame_side_data_get_c", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_get_c_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_side_data_get_c(sd, nb_sd, type);
			};
			vectors.av_frame_side_data_name = delegate(AVFrameSideDataType type)
			{
				vectors.av_frame_side_data_name = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_name_delegate>("avutil", "av_frame_side_data_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_side_data_name(type);
			};
			vectors.av_frame_side_data_new = delegate(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type, ulong size, uint flags)
			{
				vectors.av_frame_side_data_new = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_new_delegate>("avutil", "av_frame_side_data_new", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_new_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_frame_side_data_new(sd, nb_sd, type, size, flags);
			};
			vectors.av_frame_side_data_remove = delegate(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type)
			{
				vectors.av_frame_side_data_remove = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_remove_delegate>("avutil", "av_frame_side_data_remove", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_remove_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_frame_side_data_remove(sd, nb_sd, type);
			};
			vectors.av_frame_side_data_remove_by_props = delegate(AVFrameSideData*** sd, int* nb_sd, int props)
			{
				vectors.av_frame_side_data_remove_by_props = FunctionResolver.GetFunctionDelegate<vectors.av_frame_side_data_remove_by_props_delegate>("avutil", "av_frame_side_data_remove_by_props", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_side_data_remove_by_props_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_frame_side_data_remove_by_props(sd, nb_sd, props);
			};
			vectors.av_frame_unref = delegate(AVFrame* frame)
			{
				vectors.av_frame_unref = FunctionResolver.GetFunctionDelegate<vectors.av_frame_unref_delegate>("avutil", "av_frame_unref", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_frame_unref_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_frame_unref(frame);
			};
			vectors.av_free = delegate(void* ptr)
			{
				vectors.av_free = FunctionResolver.GetFunctionDelegate<vectors.av_free_delegate>("avutil", "av_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_free(ptr);
			};
			vectors.av_freep = delegate(void* ptr)
			{
				vectors.av_freep = FunctionResolver.GetFunctionDelegate<vectors.av_freep_delegate>("avutil", "av_freep", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_freep_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_freep(ptr);
			};
			vectors.av_gcd = delegate(long a, long b)
			{
				vectors.av_gcd = FunctionResolver.GetFunctionDelegate<vectors.av_gcd_delegate>("avutil", "av_gcd", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_gcd_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_gcd(a, b);
			};
			vectors.av_gcd_q = delegate(AVRational a, AVRational b, int max_den, AVRational def)
			{
				vectors.av_gcd_q = FunctionResolver.GetFunctionDelegate<vectors.av_gcd_q_delegate>("avutil", "av_gcd_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_gcd_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_gcd_q(a, b, max_den, def);
			};
			vectors.av_get_alt_sample_fmt = delegate(AVSampleFormat sample_fmt, int planar)
			{
				vectors.av_get_alt_sample_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_get_alt_sample_fmt_delegate>("avutil", "av_get_alt_sample_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_alt_sample_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_alt_sample_fmt(sample_fmt, planar);
			};
			vectors.av_get_audio_frame_duration = delegate(AVCodecContext* avctx, int frame_bytes)
			{
				vectors.av_get_audio_frame_duration = FunctionResolver.GetFunctionDelegate<vectors.av_get_audio_frame_duration_delegate>("avcodec", "av_get_audio_frame_duration", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_audio_frame_duration_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_audio_frame_duration(avctx, frame_bytes);
			};
			vectors.av_get_audio_frame_duration2 = delegate(AVCodecParameters* par, int frame_bytes)
			{
				vectors.av_get_audio_frame_duration2 = FunctionResolver.GetFunctionDelegate<vectors.av_get_audio_frame_duration2_delegate>("avcodec", "av_get_audio_frame_duration2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_audio_frame_duration2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_audio_frame_duration2(par, frame_bytes);
			};
			vectors.av_get_bits_per_pixel = delegate(AVPixFmtDescriptor* pixdesc)
			{
				vectors.av_get_bits_per_pixel = FunctionResolver.GetFunctionDelegate<vectors.av_get_bits_per_pixel_delegate>("avutil", "av_get_bits_per_pixel", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_bits_per_pixel_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_bits_per_pixel(pixdesc);
			};
			vectors.av_get_bits_per_sample = delegate(AVCodecID codec_id)
			{
				vectors.av_get_bits_per_sample = FunctionResolver.GetFunctionDelegate<vectors.av_get_bits_per_sample_delegate>("avcodec", "av_get_bits_per_sample", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_bits_per_sample_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_bits_per_sample(codec_id);
			};
			vectors.av_get_bytes_per_sample = delegate(AVSampleFormat sample_fmt)
			{
				vectors.av_get_bytes_per_sample = FunctionResolver.GetFunctionDelegate<vectors.av_get_bytes_per_sample_delegate>("avutil", "av_get_bytes_per_sample", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_bytes_per_sample_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_bytes_per_sample(sample_fmt);
			};
			vectors.av_get_cpu_flags = delegate
			{
				vectors.av_get_cpu_flags = FunctionResolver.GetFunctionDelegate<vectors.av_get_cpu_flags_delegate>("avutil", "av_get_cpu_flags", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_cpu_flags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_cpu_flags();
			};
			vectors.av_get_exact_bits_per_sample = delegate(AVCodecID codec_id)
			{
				vectors.av_get_exact_bits_per_sample = FunctionResolver.GetFunctionDelegate<vectors.av_get_exact_bits_per_sample_delegate>("avcodec", "av_get_exact_bits_per_sample", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_exact_bits_per_sample_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_exact_bits_per_sample(codec_id);
			};
			vectors.av_get_frame_filename = delegate(byte* buf, int buf_size, string path, int number)
			{
				vectors.av_get_frame_filename = FunctionResolver.GetFunctionDelegate<vectors.av_get_frame_filename_delegate>("avformat", "av_get_frame_filename", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_frame_filename_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_frame_filename(buf, buf_size, path, number);
			};
			vectors.av_get_frame_filename2 = delegate(byte* buf, int buf_size, string path, int number, int flags)
			{
				vectors.av_get_frame_filename2 = FunctionResolver.GetFunctionDelegate<vectors.av_get_frame_filename2_delegate>("avformat", "av_get_frame_filename2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_frame_filename2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_frame_filename2(buf, buf_size, path, number, flags);
			};
			vectors.av_get_media_type_string = delegate(AVMediaType media_type)
			{
				vectors.av_get_media_type_string = FunctionResolver.GetFunctionDelegate<vectors.av_get_media_type_string_delegate>("avutil", "av_get_media_type_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_media_type_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_media_type_string(media_type);
			};
			vectors.av_get_output_timestamp = delegate(AVFormatContext* s, int stream, long* dts, long* wall)
			{
				vectors.av_get_output_timestamp = FunctionResolver.GetFunctionDelegate<vectors.av_get_output_timestamp_delegate>("avformat", "av_get_output_timestamp", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_output_timestamp_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_output_timestamp(s, stream, dts, wall);
			};
			vectors.av_get_packed_sample_fmt = delegate(AVSampleFormat sample_fmt)
			{
				vectors.av_get_packed_sample_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_get_packed_sample_fmt_delegate>("avutil", "av_get_packed_sample_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_packed_sample_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_packed_sample_fmt(sample_fmt);
			};
			vectors.av_get_packet = delegate(AVIOContext* s, AVPacket* pkt, int size)
			{
				vectors.av_get_packet = FunctionResolver.GetFunctionDelegate<vectors.av_get_packet_delegate>("avformat", "av_get_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_packet(s, pkt, size);
			};
			vectors.av_get_padded_bits_per_pixel = delegate(AVPixFmtDescriptor* pixdesc)
			{
				vectors.av_get_padded_bits_per_pixel = FunctionResolver.GetFunctionDelegate<vectors.av_get_padded_bits_per_pixel_delegate>("avutil", "av_get_padded_bits_per_pixel", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_padded_bits_per_pixel_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_padded_bits_per_pixel(pixdesc);
			};
			vectors.av_get_pcm_codec = delegate(AVSampleFormat fmt, int be)
			{
				vectors.av_get_pcm_codec = FunctionResolver.GetFunctionDelegate<vectors.av_get_pcm_codec_delegate>("avcodec", "av_get_pcm_codec", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_pcm_codec_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_pcm_codec(fmt, be);
			};
			vectors.av_get_picture_type_char = delegate(AVPictureType pict_type)
			{
				vectors.av_get_picture_type_char = FunctionResolver.GetFunctionDelegate<vectors.av_get_picture_type_char_delegate>("avutil", "av_get_picture_type_char", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_picture_type_char_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_picture_type_char(pict_type);
			};
			vectors.av_get_pix_fmt = delegate(string name)
			{
				vectors.av_get_pix_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_get_pix_fmt_delegate>("avutil", "av_get_pix_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_pix_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_pix_fmt(name);
			};
			vectors.av_get_pix_fmt_loss = delegate(AVPixelFormat dst_pix_fmt, AVPixelFormat src_pix_fmt, int has_alpha)
			{
				vectors.av_get_pix_fmt_loss = FunctionResolver.GetFunctionDelegate<vectors.av_get_pix_fmt_loss_delegate>("avutil", "av_get_pix_fmt_loss", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_pix_fmt_loss_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
			};
			vectors.av_get_pix_fmt_name = delegate(AVPixelFormat pix_fmt)
			{
				vectors.av_get_pix_fmt_name = FunctionResolver.GetFunctionDelegate<vectors.av_get_pix_fmt_name_delegate>("avutil", "av_get_pix_fmt_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_pix_fmt_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_pix_fmt_name(pix_fmt);
			};
			vectors.av_get_pix_fmt_string = delegate(byte* buf, int buf_size, AVPixelFormat pix_fmt)
			{
				vectors.av_get_pix_fmt_string = FunctionResolver.GetFunctionDelegate<vectors.av_get_pix_fmt_string_delegate>("avutil", "av_get_pix_fmt_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_pix_fmt_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_pix_fmt_string(buf, buf_size, pix_fmt);
			};
			vectors.av_get_planar_sample_fmt = delegate(AVSampleFormat sample_fmt)
			{
				vectors.av_get_planar_sample_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_get_planar_sample_fmt_delegate>("avutil", "av_get_planar_sample_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_planar_sample_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_planar_sample_fmt(sample_fmt);
			};
			vectors.av_get_profile_name = delegate(AVCodec* codec, int profile)
			{
				vectors.av_get_profile_name = FunctionResolver.GetFunctionDelegate<vectors.av_get_profile_name_delegate>("avcodec", "av_get_profile_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_profile_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_profile_name(codec, profile);
			};
			vectors.av_get_sample_fmt = delegate(string name)
			{
				vectors.av_get_sample_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_get_sample_fmt_delegate>("avutil", "av_get_sample_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_sample_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_sample_fmt(name);
			};
			vectors.av_get_sample_fmt_name = delegate(AVSampleFormat sample_fmt)
			{
				vectors.av_get_sample_fmt_name = FunctionResolver.GetFunctionDelegate<vectors.av_get_sample_fmt_name_delegate>("avutil", "av_get_sample_fmt_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_sample_fmt_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_sample_fmt_name(sample_fmt);
			};
			vectors.av_get_sample_fmt_string = delegate(byte* buf, int buf_size, AVSampleFormat sample_fmt)
			{
				vectors.av_get_sample_fmt_string = FunctionResolver.GetFunctionDelegate<vectors.av_get_sample_fmt_string_delegate>("avutil", "av_get_sample_fmt_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_sample_fmt_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_sample_fmt_string(buf, buf_size, sample_fmt);
			};
			vectors.av_get_time_base_q = delegate
			{
				vectors.av_get_time_base_q = FunctionResolver.GetFunctionDelegate<vectors.av_get_time_base_q_delegate>("avutil", "av_get_time_base_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_get_time_base_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_get_time_base_q();
			};
			vectors.av_gettime = delegate
			{
				vectors.av_gettime = FunctionResolver.GetFunctionDelegate<vectors.av_gettime_delegate>("avutil", "av_gettime", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_gettime_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_gettime();
			};
			vectors.av_gettime_relative = delegate
			{
				vectors.av_gettime_relative = FunctionResolver.GetFunctionDelegate<vectors.av_gettime_relative_delegate>("avutil", "av_gettime_relative", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_gettime_relative_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_gettime_relative();
			};
			vectors.av_gettime_relative_is_monotonic = delegate
			{
				vectors.av_gettime_relative_is_monotonic = FunctionResolver.GetFunctionDelegate<vectors.av_gettime_relative_is_monotonic_delegate>("avutil", "av_gettime_relative_is_monotonic", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_gettime_relative_is_monotonic_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_gettime_relative_is_monotonic();
			};
			vectors.av_grow_packet = delegate(AVPacket* pkt, int grow_by)
			{
				vectors.av_grow_packet = FunctionResolver.GetFunctionDelegate<vectors.av_grow_packet_delegate>("avcodec", "av_grow_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_grow_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_grow_packet(pkt, grow_by);
			};
			vectors.av_guess_codec = delegate(AVOutputFormat* fmt, string short_name, string filename, string mime_type, AVMediaType type)
			{
				vectors.av_guess_codec = FunctionResolver.GetFunctionDelegate<vectors.av_guess_codec_delegate>("avformat", "av_guess_codec", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_guess_codec_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_guess_codec(fmt, short_name, filename, mime_type, type);
			};
			vectors.av_guess_format = delegate(string short_name, string filename, string mime_type)
			{
				vectors.av_guess_format = FunctionResolver.GetFunctionDelegate<vectors.av_guess_format_delegate>("avformat", "av_guess_format", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_guess_format_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_guess_format(short_name, filename, mime_type);
			};
			vectors.av_guess_frame_rate = delegate(AVFormatContext* ctx, AVStream* stream, AVFrame* frame)
			{
				vectors.av_guess_frame_rate = FunctionResolver.GetFunctionDelegate<vectors.av_guess_frame_rate_delegate>("avformat", "av_guess_frame_rate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_guess_frame_rate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_guess_frame_rate(ctx, stream, frame);
			};
			vectors.av_guess_sample_aspect_ratio = delegate(AVFormatContext* format, AVStream* stream, AVFrame* frame)
			{
				vectors.av_guess_sample_aspect_ratio = FunctionResolver.GetFunctionDelegate<vectors.av_guess_sample_aspect_ratio_delegate>("avformat", "av_guess_sample_aspect_ratio", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_guess_sample_aspect_ratio_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_guess_sample_aspect_ratio(format, stream, frame);
			};
			vectors.av_hex_dump = delegate(_iobuf* f, byte* buf, int size)
			{
				vectors.av_hex_dump = FunctionResolver.GetFunctionDelegate<vectors.av_hex_dump_delegate>("avformat", "av_hex_dump", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hex_dump_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_hex_dump(f, buf, size);
			};
			vectors.av_hex_dump_log = delegate(void* avcl, int level, byte* buf, int size)
			{
				vectors.av_hex_dump_log = FunctionResolver.GetFunctionDelegate<vectors.av_hex_dump_log_delegate>("avformat", "av_hex_dump_log", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hex_dump_log_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_hex_dump_log(avcl, level, buf, size);
			};
			vectors.av_hwdevice_ctx_alloc = delegate(AVHWDeviceType type)
			{
				vectors.av_hwdevice_ctx_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_ctx_alloc_delegate>("avutil", "av_hwdevice_ctx_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_ctx_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_ctx_alloc(type);
			};
			vectors.av_hwdevice_ctx_create = delegate(AVBufferRef** device_ctx, AVHWDeviceType type, string device, AVDictionary* opts, int flags)
			{
				vectors.av_hwdevice_ctx_create = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_ctx_create_delegate>("avutil", "av_hwdevice_ctx_create", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_ctx_create_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_ctx_create(device_ctx, type, device, opts, flags);
			};
			vectors.av_hwdevice_ctx_create_derived = delegate(AVBufferRef** dst_ctx, AVHWDeviceType type, AVBufferRef* src_ctx, int flags)
			{
				vectors.av_hwdevice_ctx_create_derived = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_ctx_create_derived_delegate>("avutil", "av_hwdevice_ctx_create_derived", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_ctx_create_derived_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_ctx_create_derived(dst_ctx, type, src_ctx, flags);
			};
			vectors.av_hwdevice_ctx_create_derived_opts = delegate(AVBufferRef** dst_ctx, AVHWDeviceType type, AVBufferRef* src_ctx, AVDictionary* options, int flags)
			{
				vectors.av_hwdevice_ctx_create_derived_opts = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_ctx_create_derived_opts_delegate>("avutil", "av_hwdevice_ctx_create_derived_opts", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_ctx_create_derived_opts_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_ctx_create_derived_opts(dst_ctx, type, src_ctx, options, flags);
			};
			vectors.av_hwdevice_ctx_init = delegate(AVBufferRef* @ref)
			{
				vectors.av_hwdevice_ctx_init = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_ctx_init_delegate>("avutil", "av_hwdevice_ctx_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_ctx_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_ctx_init(@ref);
			};
			vectors.av_hwdevice_find_type_by_name = delegate(string name)
			{
				vectors.av_hwdevice_find_type_by_name = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_find_type_by_name_delegate>("avutil", "av_hwdevice_find_type_by_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_find_type_by_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_find_type_by_name(name);
			};
			vectors.av_hwdevice_get_hwframe_constraints = delegate(AVBufferRef* @ref, void* hwconfig)
			{
				vectors.av_hwdevice_get_hwframe_constraints = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_get_hwframe_constraints_delegate>("avutil", "av_hwdevice_get_hwframe_constraints", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_get_hwframe_constraints_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_get_hwframe_constraints(@ref, hwconfig);
			};
			vectors.av_hwdevice_get_type_name = delegate(AVHWDeviceType type)
			{
				vectors.av_hwdevice_get_type_name = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_get_type_name_delegate>("avutil", "av_hwdevice_get_type_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_get_type_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_get_type_name(type);
			};
			vectors.av_hwdevice_hwconfig_alloc = delegate(AVBufferRef* device_ctx)
			{
				vectors.av_hwdevice_hwconfig_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_hwconfig_alloc_delegate>("avutil", "av_hwdevice_hwconfig_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_hwconfig_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_hwconfig_alloc(device_ctx);
			};
			vectors.av_hwdevice_iterate_types = delegate(AVHWDeviceType prev)
			{
				vectors.av_hwdevice_iterate_types = FunctionResolver.GetFunctionDelegate<vectors.av_hwdevice_iterate_types_delegate>("avutil", "av_hwdevice_iterate_types", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwdevice_iterate_types_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwdevice_iterate_types(prev);
			};
			vectors.av_hwframe_constraints_free = delegate(AVHWFramesConstraints** constraints)
			{
				vectors.av_hwframe_constraints_free = FunctionResolver.GetFunctionDelegate<vectors.av_hwframe_constraints_free_delegate>("avutil", "av_hwframe_constraints_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwframe_constraints_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_hwframe_constraints_free(constraints);
			};
			vectors.av_hwframe_ctx_alloc = delegate(AVBufferRef* device_ctx)
			{
				vectors.av_hwframe_ctx_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_hwframe_ctx_alloc_delegate>("avutil", "av_hwframe_ctx_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwframe_ctx_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwframe_ctx_alloc(device_ctx);
			};
			vectors.av_hwframe_ctx_create_derived = delegate(AVBufferRef** derived_frame_ctx, AVPixelFormat format, AVBufferRef* derived_device_ctx, AVBufferRef* source_frame_ctx, int flags)
			{
				vectors.av_hwframe_ctx_create_derived = FunctionResolver.GetFunctionDelegate<vectors.av_hwframe_ctx_create_derived_delegate>("avutil", "av_hwframe_ctx_create_derived", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwframe_ctx_create_derived_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwframe_ctx_create_derived(derived_frame_ctx, format, derived_device_ctx, source_frame_ctx, flags);
			};
			vectors.av_hwframe_ctx_init = delegate(AVBufferRef* @ref)
			{
				vectors.av_hwframe_ctx_init = FunctionResolver.GetFunctionDelegate<vectors.av_hwframe_ctx_init_delegate>("avutil", "av_hwframe_ctx_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwframe_ctx_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwframe_ctx_init(@ref);
			};
			vectors.av_hwframe_get_buffer = delegate(AVBufferRef* hwframe_ctx, AVFrame* frame, int flags)
			{
				vectors.av_hwframe_get_buffer = FunctionResolver.GetFunctionDelegate<vectors.av_hwframe_get_buffer_delegate>("avutil", "av_hwframe_get_buffer", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwframe_get_buffer_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwframe_get_buffer(hwframe_ctx, frame, flags);
			};
			vectors.av_hwframe_map = delegate(AVFrame* dst, AVFrame* src, int flags)
			{
				vectors.av_hwframe_map = FunctionResolver.GetFunctionDelegate<vectors.av_hwframe_map_delegate>("avutil", "av_hwframe_map", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwframe_map_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwframe_map(dst, src, flags);
			};
			vectors.av_hwframe_transfer_data = delegate(AVFrame* dst, AVFrame* src, int flags)
			{
				vectors.av_hwframe_transfer_data = FunctionResolver.GetFunctionDelegate<vectors.av_hwframe_transfer_data_delegate>("avutil", "av_hwframe_transfer_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwframe_transfer_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwframe_transfer_data(dst, src, flags);
			};
			vectors.av_hwframe_transfer_get_formats = delegate(AVBufferRef* hwframe_ctx, AVHWFrameTransferDirection dir, AVPixelFormat** formats, int flags)
			{
				vectors.av_hwframe_transfer_get_formats = FunctionResolver.GetFunctionDelegate<vectors.av_hwframe_transfer_get_formats_delegate>("avutil", "av_hwframe_transfer_get_formats", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_hwframe_transfer_get_formats_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_hwframe_transfer_get_formats(hwframe_ctx, dir, formats, flags);
			};
			vectors.av_image_alloc = delegate(ref byte_ptrArray4 pointers, ref int_array4 linesizes, int w, int h, AVPixelFormat pix_fmt, int align)
			{
				vectors.av_image_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_image_alloc_delegate>("avutil", "av_image_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_alloc(ref pointers, ref linesizes, w, h, pix_fmt, align);
			};
			vectors.av_image_check_sar = delegate(uint w, uint h, AVRational sar)
			{
				vectors.av_image_check_sar = FunctionResolver.GetFunctionDelegate<vectors.av_image_check_sar_delegate>("avutil", "av_image_check_sar", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_check_sar_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_check_sar(w, h, sar);
			};
			vectors.av_image_check_size = delegate(uint w, uint h, int log_offset, void* log_ctx)
			{
				vectors.av_image_check_size = FunctionResolver.GetFunctionDelegate<vectors.av_image_check_size_delegate>("avutil", "av_image_check_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_check_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_check_size(w, h, log_offset, log_ctx);
			};
			vectors.av_image_check_size2 = delegate(uint w, uint h, long max_pixels, AVPixelFormat pix_fmt, int log_offset, void* log_ctx)
			{
				vectors.av_image_check_size2 = FunctionResolver.GetFunctionDelegate<vectors.av_image_check_size2_delegate>("avutil", "av_image_check_size2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_check_size2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_check_size2(w, h, max_pixels, pix_fmt, log_offset, log_ctx);
			};
			vectors.av_image_copy = delegate(ref byte_ptrArray4 dst_data, in int_array4 dst_linesizes, in byte_ptrArray4 src_data, in int_array4 src_linesizes, AVPixelFormat pix_fmt, int width, int height)
			{
				vectors.av_image_copy = FunctionResolver.GetFunctionDelegate<vectors.av_image_copy_delegate>("avutil", "av_image_copy", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_copy_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_image_copy(ref dst_data, in dst_linesizes, in src_data, in src_linesizes, pix_fmt, width, height);
			};
			vectors.av_image_copy_plane = delegate(byte* dst, int dst_linesize, byte* src, int src_linesize, int bytewidth, int height)
			{
				vectors.av_image_copy_plane = FunctionResolver.GetFunctionDelegate<vectors.av_image_copy_plane_delegate>("avutil", "av_image_copy_plane", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_copy_plane_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_image_copy_plane(dst, dst_linesize, src, src_linesize, bytewidth, height);
			};
			vectors.av_image_copy_plane_uc_from = delegate(byte* dst, long dst_linesize, byte* src, long src_linesize, long bytewidth, int height)
			{
				vectors.av_image_copy_plane_uc_from = FunctionResolver.GetFunctionDelegate<vectors.av_image_copy_plane_uc_from_delegate>("avutil", "av_image_copy_plane_uc_from", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_copy_plane_uc_from_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_image_copy_plane_uc_from(dst, dst_linesize, src, src_linesize, bytewidth, height);
			};
			vectors.av_image_copy_to_buffer = delegate(byte* dst, int dst_size, in byte_ptrArray4 src_data, in int_array4 src_linesize, AVPixelFormat pix_fmt, int width, int height, int align)
			{
				vectors.av_image_copy_to_buffer = FunctionResolver.GetFunctionDelegate<vectors.av_image_copy_to_buffer_delegate>("avutil", "av_image_copy_to_buffer", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_copy_to_buffer_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_copy_to_buffer(dst, dst_size, in src_data, in src_linesize, pix_fmt, width, height, align);
			};
			vectors.av_image_copy_uc_from = delegate(ref byte_ptrArray4 dst_data, in long_array4 dst_linesizes, in byte_ptrArray4 src_data, in long_array4 src_linesizes, AVPixelFormat pix_fmt, int width, int height)
			{
				vectors.av_image_copy_uc_from = FunctionResolver.GetFunctionDelegate<vectors.av_image_copy_uc_from_delegate>("avutil", "av_image_copy_uc_from", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_copy_uc_from_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_image_copy_uc_from(ref dst_data, in dst_linesizes, in src_data, in src_linesizes, pix_fmt, width, height);
			};
			vectors.av_image_fill_arrays = delegate(ref byte_ptrArray4 dst_data, ref int_array4 dst_linesize, byte* src, AVPixelFormat pix_fmt, int width, int height, int align)
			{
				vectors.av_image_fill_arrays = FunctionResolver.GetFunctionDelegate<vectors.av_image_fill_arrays_delegate>("avutil", "av_image_fill_arrays", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_fill_arrays_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_fill_arrays(ref dst_data, ref dst_linesize, src, pix_fmt, width, height, align);
			};
			vectors.av_image_fill_black = delegate(ref byte_ptrArray4 dst_data, in long_array4 dst_linesize, AVPixelFormat pix_fmt, AVColorRange range, int width, int height)
			{
				vectors.av_image_fill_black = FunctionResolver.GetFunctionDelegate<vectors.av_image_fill_black_delegate>("avutil", "av_image_fill_black", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_fill_black_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_fill_black(ref dst_data, in dst_linesize, pix_fmt, range, width, height);
			};
			vectors.av_image_fill_color = delegate(ref byte_ptrArray4 dst_data, in long_array4 dst_linesize, AVPixelFormat pix_fmt, in uint_array4 color, int width, int height, int flags)
			{
				vectors.av_image_fill_color = FunctionResolver.GetFunctionDelegate<vectors.av_image_fill_color_delegate>("avutil", "av_image_fill_color", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_fill_color_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_fill_color(ref dst_data, in dst_linesize, pix_fmt, in color, width, height, flags);
			};
			vectors.av_image_fill_linesizes = delegate(ref int_array4 linesizes, AVPixelFormat pix_fmt, int width)
			{
				vectors.av_image_fill_linesizes = FunctionResolver.GetFunctionDelegate<vectors.av_image_fill_linesizes_delegate>("avutil", "av_image_fill_linesizes", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_fill_linesizes_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_fill_linesizes(ref linesizes, pix_fmt, width);
			};
			vectors.av_image_fill_max_pixsteps = delegate(ref int_array4 max_pixsteps, ref int_array4 max_pixstep_comps, AVPixFmtDescriptor* pixdesc)
			{
				vectors.av_image_fill_max_pixsteps = FunctionResolver.GetFunctionDelegate<vectors.av_image_fill_max_pixsteps_delegate>("avutil", "av_image_fill_max_pixsteps", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_fill_max_pixsteps_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_image_fill_max_pixsteps(ref max_pixsteps, ref max_pixstep_comps, pixdesc);
			};
			vectors.av_image_fill_plane_sizes = delegate(ref ulong_array4 size, AVPixelFormat pix_fmt, int height, in long_array4 linesizes)
			{
				vectors.av_image_fill_plane_sizes = FunctionResolver.GetFunctionDelegate<vectors.av_image_fill_plane_sizes_delegate>("avutil", "av_image_fill_plane_sizes", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_fill_plane_sizes_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_fill_plane_sizes(ref size, pix_fmt, height, in linesizes);
			};
			vectors.av_image_fill_pointers = delegate(ref byte_ptrArray4 data, AVPixelFormat pix_fmt, int height, byte* ptr, in int_array4 linesizes)
			{
				vectors.av_image_fill_pointers = FunctionResolver.GetFunctionDelegate<vectors.av_image_fill_pointers_delegate>("avutil", "av_image_fill_pointers", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_fill_pointers_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_fill_pointers(ref data, pix_fmt, height, ptr, in linesizes);
			};
			vectors.av_image_get_buffer_size = delegate(AVPixelFormat pix_fmt, int width, int height, int align)
			{
				vectors.av_image_get_buffer_size = FunctionResolver.GetFunctionDelegate<vectors.av_image_get_buffer_size_delegate>("avutil", "av_image_get_buffer_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_get_buffer_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_get_buffer_size(pix_fmt, width, height, align);
			};
			vectors.av_image_get_linesize = delegate(AVPixelFormat pix_fmt, int width, int plane)
			{
				vectors.av_image_get_linesize = FunctionResolver.GetFunctionDelegate<vectors.av_image_get_linesize_delegate>("avutil", "av_image_get_linesize", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_image_get_linesize_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_image_get_linesize(pix_fmt, width, plane);
			};
			vectors.av_index_search_timestamp = delegate(AVStream* st, long timestamp, int flags)
			{
				vectors.av_index_search_timestamp = FunctionResolver.GetFunctionDelegate<vectors.av_index_search_timestamp_delegate>("avformat", "av_index_search_timestamp", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_index_search_timestamp_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_index_search_timestamp(st, timestamp, flags);
			};
			vectors.av_init_packet = delegate(AVPacket* pkt)
			{
				vectors.av_init_packet = FunctionResolver.GetFunctionDelegate<vectors.av_init_packet_delegate>("avcodec", "av_init_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_init_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_init_packet(pkt);
			};
			vectors.av_input_audio_device_next = delegate(AVInputFormat* d)
			{
				vectors.av_input_audio_device_next = FunctionResolver.GetFunctionDelegate<vectors.av_input_audio_device_next_delegate>("avdevice", "av_input_audio_device_next", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_input_audio_device_next_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_input_audio_device_next(d);
			};
			vectors.av_input_video_device_next = delegate(AVInputFormat* d)
			{
				vectors.av_input_video_device_next = FunctionResolver.GetFunctionDelegate<vectors.av_input_video_device_next_delegate>("avdevice", "av_input_video_device_next", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_input_video_device_next_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_input_video_device_next(d);
			};
			vectors.av_int_list_length_for_size = delegate(uint elsize, void* list, ulong term)
			{
				vectors.av_int_list_length_for_size = FunctionResolver.GetFunctionDelegate<vectors.av_int_list_length_for_size_delegate>("avutil", "av_int_list_length_for_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_int_list_length_for_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_int_list_length_for_size(elsize, list, term);
			};
			vectors.av_interleaved_write_frame = delegate(AVFormatContext* s, AVPacket* pkt)
			{
				vectors.av_interleaved_write_frame = FunctionResolver.GetFunctionDelegate<vectors.av_interleaved_write_frame_delegate>("avformat", "av_interleaved_write_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_interleaved_write_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_interleaved_write_frame(s, pkt);
			};
			vectors.av_interleaved_write_uncoded_frame = delegate(AVFormatContext* s, int stream_index, AVFrame* frame)
			{
				vectors.av_interleaved_write_uncoded_frame = FunctionResolver.GetFunctionDelegate<vectors.av_interleaved_write_uncoded_frame_delegate>("avformat", "av_interleaved_write_uncoded_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_interleaved_write_uncoded_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_interleaved_write_uncoded_frame(s, stream_index, frame);
			};
			vectors.av_log = delegate(void* avcl, int level, string fmt)
			{
				vectors.av_log = FunctionResolver.GetFunctionDelegate<vectors.av_log_delegate>("avutil", "av_log", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_log(avcl, level, fmt);
			};
			vectors.av_log_default_callback = delegate(void* avcl, int level, string fmt, byte* vl)
			{
				vectors.av_log_default_callback = FunctionResolver.GetFunctionDelegate<vectors.av_log_default_callback_delegate>("avutil", "av_log_default_callback", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_default_callback_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_log_default_callback(avcl, level, fmt, vl);
			};
			vectors.av_log_format_line = delegate(void* ptr, int level, string fmt, byte* vl, byte* line, int line_size, int* print_prefix)
			{
				vectors.av_log_format_line = FunctionResolver.GetFunctionDelegate<vectors.av_log_format_line_delegate>("avutil", "av_log_format_line", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_format_line_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_log_format_line(ptr, level, fmt, vl, line, line_size, print_prefix);
			};
			vectors.av_log_format_line2 = delegate(void* ptr, int level, string fmt, byte* vl, byte* line, int line_size, int* print_prefix)
			{
				vectors.av_log_format_line2 = FunctionResolver.GetFunctionDelegate<vectors.av_log_format_line2_delegate>("avutil", "av_log_format_line2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_format_line2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_log_format_line2(ptr, level, fmt, vl, line, line_size, print_prefix);
			};
			vectors.av_log_get_flags = delegate
			{
				vectors.av_log_get_flags = FunctionResolver.GetFunctionDelegate<vectors.av_log_get_flags_delegate>("avutil", "av_log_get_flags", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_get_flags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_log_get_flags();
			};
			vectors.av_log_get_level = delegate
			{
				vectors.av_log_get_level = FunctionResolver.GetFunctionDelegate<vectors.av_log_get_level_delegate>("avutil", "av_log_get_level", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_get_level_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_log_get_level();
			};
			vectors.av_log_once = delegate(void* avcl, int initial_level, int subsequent_level, int* state, string fmt)
			{
				vectors.av_log_once = FunctionResolver.GetFunctionDelegate<vectors.av_log_once_delegate>("avutil", "av_log_once", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_once_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_log_once(avcl, initial_level, subsequent_level, state, fmt);
			};
			vectors.av_log_set_callback = delegate(av_log_set_callback_callback_func callback)
			{
				vectors.av_log_set_callback = FunctionResolver.GetFunctionDelegate<vectors.av_log_set_callback_delegate>("avutil", "av_log_set_callback", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_set_callback_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_log_set_callback(callback);
			};
			vectors.av_log_set_flags = delegate(int arg)
			{
				vectors.av_log_set_flags = FunctionResolver.GetFunctionDelegate<vectors.av_log_set_flags_delegate>("avutil", "av_log_set_flags", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_set_flags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_log_set_flags(arg);
			};
			vectors.av_log_set_level = delegate(int level)
			{
				vectors.av_log_set_level = FunctionResolver.GetFunctionDelegate<vectors.av_log_set_level_delegate>("avutil", "av_log_set_level", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log_set_level_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_log_set_level(level);
			};
			vectors.av_log2 = delegate(uint v)
			{
				vectors.av_log2 = FunctionResolver.GetFunctionDelegate<vectors.av_log2_delegate>("avutil", "av_log2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_log2(v);
			};
			vectors.av_log2_16bit = delegate(uint v)
			{
				vectors.av_log2_16bit = FunctionResolver.GetFunctionDelegate<vectors.av_log2_16bit_delegate>("avutil", "av_log2_16bit", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_log2_16bit_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_log2_16bit(v);
			};
			vectors.av_malloc = delegate(ulong size)
			{
				vectors.av_malloc = FunctionResolver.GetFunctionDelegate<vectors.av_malloc_delegate>("avutil", "av_malloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_malloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_malloc(size);
			};
			vectors.av_malloc_array = delegate(ulong nmemb, ulong size)
			{
				vectors.av_malloc_array = FunctionResolver.GetFunctionDelegate<vectors.av_malloc_array_delegate>("avutil", "av_malloc_array", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_malloc_array_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_malloc_array(nmemb, size);
			};
			vectors.av_mallocz = delegate(ulong size)
			{
				vectors.av_mallocz = FunctionResolver.GetFunctionDelegate<vectors.av_mallocz_delegate>("avutil", "av_mallocz", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_mallocz_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_mallocz(size);
			};
			vectors.av_mastering_display_metadata_alloc = delegate
			{
				vectors.av_mastering_display_metadata_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_mastering_display_metadata_alloc_delegate>("avutil", "av_mastering_display_metadata_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_mastering_display_metadata_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_mastering_display_metadata_alloc();
			};
			vectors.av_mastering_display_metadata_alloc_size = delegate(ulong* size)
			{
				vectors.av_mastering_display_metadata_alloc_size = FunctionResolver.GetFunctionDelegate<vectors.av_mastering_display_metadata_alloc_size_delegate>("avutil", "av_mastering_display_metadata_alloc_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_mastering_display_metadata_alloc_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_mastering_display_metadata_alloc_size(size);
			};
			vectors.av_mastering_display_metadata_create_side_data = delegate(AVFrame* frame)
			{
				vectors.av_mastering_display_metadata_create_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_mastering_display_metadata_create_side_data_delegate>("avutil", "av_mastering_display_metadata_create_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_mastering_display_metadata_create_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_mastering_display_metadata_create_side_data(frame);
			};
			vectors.av_match_ext = delegate(string filename, string extensions)
			{
				vectors.av_match_ext = FunctionResolver.GetFunctionDelegate<vectors.av_match_ext_delegate>("avformat", "av_match_ext", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_match_ext_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_match_ext(filename, extensions);
			};
			vectors.av_max_alloc = delegate(ulong max)
			{
				vectors.av_max_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_max_alloc_delegate>("avutil", "av_max_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_max_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_max_alloc(max);
			};
			vectors.av_memcpy_backptr = delegate(byte* dst, int back, int cnt)
			{
				vectors.av_memcpy_backptr = FunctionResolver.GetFunctionDelegate<vectors.av_memcpy_backptr_delegate>("avutil", "av_memcpy_backptr", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_memcpy_backptr_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_memcpy_backptr(dst, back, cnt);
			};
			vectors.av_memdup = delegate(void* p, ulong size)
			{
				vectors.av_memdup = FunctionResolver.GetFunctionDelegate<vectors.av_memdup_delegate>("avutil", "av_memdup", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_memdup_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_memdup(p, size);
			};
			vectors.av_mul_q = delegate(AVRational b, AVRational c)
			{
				vectors.av_mul_q = FunctionResolver.GetFunctionDelegate<vectors.av_mul_q_delegate>("avutil", "av_mul_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_mul_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_mul_q(b, c);
			};
			vectors.av_muxer_iterate = delegate(void** opaque)
			{
				vectors.av_muxer_iterate = FunctionResolver.GetFunctionDelegate<vectors.av_muxer_iterate_delegate>("avformat", "av_muxer_iterate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_muxer_iterate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_muxer_iterate(opaque);
			};
			vectors.av_nearer_q = delegate(AVRational q, AVRational q1, AVRational q2)
			{
				vectors.av_nearer_q = FunctionResolver.GetFunctionDelegate<vectors.av_nearer_q_delegate>("avutil", "av_nearer_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_nearer_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_nearer_q(q, q1, q2);
			};
			vectors.av_new_packet = delegate(AVPacket* pkt, int size)
			{
				vectors.av_new_packet = FunctionResolver.GetFunctionDelegate<vectors.av_new_packet_delegate>("avcodec", "av_new_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_new_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_new_packet(pkt, size);
			};
			vectors.av_new_program = delegate(AVFormatContext* s, int id)
			{
				vectors.av_new_program = FunctionResolver.GetFunctionDelegate<vectors.av_new_program_delegate>("avformat", "av_new_program", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_new_program_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_new_program(s, id);
			};
			vectors.av_opt_child_class_iterate = delegate(AVClass* parent, void** iter)
			{
				vectors.av_opt_child_class_iterate = FunctionResolver.GetFunctionDelegate<vectors.av_opt_child_class_iterate_delegate>("avutil", "av_opt_child_class_iterate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_child_class_iterate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_child_class_iterate(parent, iter);
			};
			vectors.av_opt_child_next = delegate(void* obj, void* prev)
			{
				vectors.av_opt_child_next = FunctionResolver.GetFunctionDelegate<vectors.av_opt_child_next_delegate>("avutil", "av_opt_child_next", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_child_next_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_child_next(obj, prev);
			};
			vectors.av_opt_copy = delegate(void* dest, void* src)
			{
				vectors.av_opt_copy = FunctionResolver.GetFunctionDelegate<vectors.av_opt_copy_delegate>("avutil", "av_opt_copy", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_copy_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_copy(dest, src);
			};
			vectors.av_opt_eval_double = delegate(void* obj, AVOption* o, string val, double* double_out)
			{
				vectors.av_opt_eval_double = FunctionResolver.GetFunctionDelegate<vectors.av_opt_eval_double_delegate>("avutil", "av_opt_eval_double", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_eval_double_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_eval_double(obj, o, val, double_out);
			};
			vectors.av_opt_eval_flags = delegate(void* obj, AVOption* o, string val, int* flags_out)
			{
				vectors.av_opt_eval_flags = FunctionResolver.GetFunctionDelegate<vectors.av_opt_eval_flags_delegate>("avutil", "av_opt_eval_flags", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_eval_flags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_eval_flags(obj, o, val, flags_out);
			};
			vectors.av_opt_eval_float = delegate(void* obj, AVOption* o, string val, float* float_out)
			{
				vectors.av_opt_eval_float = FunctionResolver.GetFunctionDelegate<vectors.av_opt_eval_float_delegate>("avutil", "av_opt_eval_float", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_eval_float_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_eval_float(obj, o, val, float_out);
			};
			vectors.av_opt_eval_int = delegate(void* obj, AVOption* o, string val, int* int_out)
			{
				vectors.av_opt_eval_int = FunctionResolver.GetFunctionDelegate<vectors.av_opt_eval_int_delegate>("avutil", "av_opt_eval_int", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_eval_int_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_eval_int(obj, o, val, int_out);
			};
			vectors.av_opt_eval_int64 = delegate(void* obj, AVOption* o, string val, long* int64_out)
			{
				vectors.av_opt_eval_int64 = FunctionResolver.GetFunctionDelegate<vectors.av_opt_eval_int64_delegate>("avutil", "av_opt_eval_int64", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_eval_int64_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_eval_int64(obj, o, val, int64_out);
			};
			vectors.av_opt_eval_q = delegate(void* obj, AVOption* o, string val, AVRational* q_out)
			{
				vectors.av_opt_eval_q = FunctionResolver.GetFunctionDelegate<vectors.av_opt_eval_q_delegate>("avutil", "av_opt_eval_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_eval_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_eval_q(obj, o, val, q_out);
			};
			vectors.av_opt_eval_uint = delegate(void* obj, AVOption* o, string val, uint* uint_out)
			{
				vectors.av_opt_eval_uint = FunctionResolver.GetFunctionDelegate<vectors.av_opt_eval_uint_delegate>("avutil", "av_opt_eval_uint", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_eval_uint_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_eval_uint(obj, o, val, uint_out);
			};
			vectors.av_opt_find = delegate(void* obj, string name, string unit, int opt_flags, int search_flags)
			{
				vectors.av_opt_find = FunctionResolver.GetFunctionDelegate<vectors.av_opt_find_delegate>("avutil", "av_opt_find", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_find_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_find(obj, name, unit, opt_flags, search_flags);
			};
			vectors.av_opt_find2 = delegate(void* obj, string name, string unit, int opt_flags, int search_flags, void** target_obj)
			{
				vectors.av_opt_find2 = FunctionResolver.GetFunctionDelegate<vectors.av_opt_find2_delegate>("avutil", "av_opt_find2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_find2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_find2(obj, name, unit, opt_flags, search_flags, target_obj);
			};
			vectors.av_opt_flag_is_set = delegate(void* obj, string field_name, string flag_name)
			{
				vectors.av_opt_flag_is_set = FunctionResolver.GetFunctionDelegate<vectors.av_opt_flag_is_set_delegate>("avutil", "av_opt_flag_is_set", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_flag_is_set_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_flag_is_set(obj, field_name, flag_name);
			};
			vectors.av_opt_free = delegate(void* obj)
			{
				vectors.av_opt_free = FunctionResolver.GetFunctionDelegate<vectors.av_opt_free_delegate>("avutil", "av_opt_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_opt_free(obj);
			};
			vectors.av_opt_freep_ranges = delegate(AVOptionRanges** ranges)
			{
				vectors.av_opt_freep_ranges = FunctionResolver.GetFunctionDelegate<vectors.av_opt_freep_ranges_delegate>("avutil", "av_opt_freep_ranges", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_freep_ranges_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_opt_freep_ranges(ranges);
			};
			vectors.av_opt_get = delegate(void* obj, string name, int search_flags, byte** out_val)
			{
				vectors.av_opt_get = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_delegate>("avutil", "av_opt_get", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get(obj, name, search_flags, out_val);
			};
			vectors.av_opt_get_array = delegate(void* obj, string name, int search_flags, uint start_elem, uint nb_elems, AVOptionType out_type, void* out_val)
			{
				vectors.av_opt_get_array = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_array_delegate>("avutil", "av_opt_get_array", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_array_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_array(obj, name, search_flags, start_elem, nb_elems, out_type, out_val);
			};
			vectors.av_opt_get_array_size = delegate(void* obj, string name, int search_flags, uint* out_val)
			{
				vectors.av_opt_get_array_size = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_array_size_delegate>("avutil", "av_opt_get_array_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_array_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_array_size(obj, name, search_flags, out_val);
			};
			vectors.av_opt_get_chlayout = delegate(void* obj, string name, int search_flags, AVChannelLayout* layout)
			{
				vectors.av_opt_get_chlayout = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_chlayout_delegate>("avutil", "av_opt_get_chlayout", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_chlayout_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_chlayout(obj, name, search_flags, layout);
			};
			vectors.av_opt_get_dict_val = delegate(void* obj, string name, int search_flags, AVDictionary** out_val)
			{
				vectors.av_opt_get_dict_val = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_dict_val_delegate>("avutil", "av_opt_get_dict_val", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_dict_val_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_dict_val(obj, name, search_flags, out_val);
			};
			vectors.av_opt_get_double = delegate(void* obj, string name, int search_flags, double* out_val)
			{
				vectors.av_opt_get_double = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_double_delegate>("avutil", "av_opt_get_double", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_double_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_double(obj, name, search_flags, out_val);
			};
			vectors.av_opt_get_image_size = delegate(void* obj, string name, int search_flags, int* w_out, int* h_out)
			{
				vectors.av_opt_get_image_size = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_image_size_delegate>("avutil", "av_opt_get_image_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_image_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_image_size(obj, name, search_flags, w_out, h_out);
			};
			vectors.av_opt_get_int = delegate(void* obj, string name, int search_flags, long* out_val)
			{
				vectors.av_opt_get_int = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_int_delegate>("avutil", "av_opt_get_int", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_int_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_int(obj, name, search_flags, out_val);
			};
			vectors.av_opt_get_key_value = delegate(byte** ropts, string key_val_sep, string pairs_sep, uint flags, byte** rkey, byte** rval)
			{
				vectors.av_opt_get_key_value = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_key_value_delegate>("avutil", "av_opt_get_key_value", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_key_value_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_key_value(ropts, key_val_sep, pairs_sep, flags, rkey, rval);
			};
			vectors.av_opt_get_pixel_fmt = delegate(void* obj, string name, int search_flags, AVPixelFormat* out_fmt)
			{
				vectors.av_opt_get_pixel_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_pixel_fmt_delegate>("avutil", "av_opt_get_pixel_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_pixel_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_pixel_fmt(obj, name, search_flags, out_fmt);
			};
			vectors.av_opt_get_q = delegate(void* obj, string name, int search_flags, AVRational* out_val)
			{
				vectors.av_opt_get_q = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_q_delegate>("avutil", "av_opt_get_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_q(obj, name, search_flags, out_val);
			};
			vectors.av_opt_get_sample_fmt = delegate(void* obj, string name, int search_flags, AVSampleFormat* out_fmt)
			{
				vectors.av_opt_get_sample_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_sample_fmt_delegate>("avutil", "av_opt_get_sample_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_sample_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_sample_fmt(obj, name, search_flags, out_fmt);
			};
			vectors.av_opt_get_video_rate = delegate(void* obj, string name, int search_flags, AVRational* out_val)
			{
				vectors.av_opt_get_video_rate = FunctionResolver.GetFunctionDelegate<vectors.av_opt_get_video_rate_delegate>("avutil", "av_opt_get_video_rate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_get_video_rate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_get_video_rate(obj, name, search_flags, out_val);
			};
			vectors.av_opt_is_set_to_default = delegate(void* obj, AVOption* o)
			{
				vectors.av_opt_is_set_to_default = FunctionResolver.GetFunctionDelegate<vectors.av_opt_is_set_to_default_delegate>("avutil", "av_opt_is_set_to_default", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_is_set_to_default_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_is_set_to_default(obj, o);
			};
			vectors.av_opt_is_set_to_default_by_name = delegate(void* obj, string name, int search_flags)
			{
				vectors.av_opt_is_set_to_default_by_name = FunctionResolver.GetFunctionDelegate<vectors.av_opt_is_set_to_default_by_name_delegate>("avutil", "av_opt_is_set_to_default_by_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_is_set_to_default_by_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_is_set_to_default_by_name(obj, name, search_flags);
			};
			vectors.av_opt_next = delegate(void* obj, AVOption* prev)
			{
				vectors.av_opt_next = FunctionResolver.GetFunctionDelegate<vectors.av_opt_next_delegate>("avutil", "av_opt_next", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_next_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_next(obj, prev);
			};
			vectors.av_opt_ptr = delegate(AVClass* avclass, void* obj, string name)
			{
				vectors.av_opt_ptr = FunctionResolver.GetFunctionDelegate<vectors.av_opt_ptr_delegate>("avutil", "av_opt_ptr", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_ptr_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_ptr(avclass, obj, name);
			};
			vectors.av_opt_query_ranges = delegate(AVOptionRanges** p0, void* obj, string key, int flags)
			{
				vectors.av_opt_query_ranges = FunctionResolver.GetFunctionDelegate<vectors.av_opt_query_ranges_delegate>("avutil", "av_opt_query_ranges", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_query_ranges_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_query_ranges(p0, obj, key, flags);
			};
			vectors.av_opt_query_ranges_default = delegate(AVOptionRanges** p0, void* obj, string key, int flags)
			{
				vectors.av_opt_query_ranges_default = FunctionResolver.GetFunctionDelegate<vectors.av_opt_query_ranges_default_delegate>("avutil", "av_opt_query_ranges_default", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_query_ranges_default_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_query_ranges_default(p0, obj, key, flags);
			};
			vectors.av_opt_serialize = delegate(void* obj, int opt_flags, int flags, byte** buffer, byte key_val_sep, byte pairs_sep)
			{
				vectors.av_opt_serialize = FunctionResolver.GetFunctionDelegate<vectors.av_opt_serialize_delegate>("avutil", "av_opt_serialize", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_serialize_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_serialize(obj, opt_flags, flags, buffer, key_val_sep, pairs_sep);
			};
			vectors.av_opt_set = delegate(void* obj, string name, string val, int search_flags)
			{
				vectors.av_opt_set = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_delegate>("avutil", "av_opt_set", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set(obj, name, val, search_flags);
			};
			vectors.av_opt_set_array = delegate(void* obj, string name, int search_flags, uint start_elem, uint nb_elems, AVOptionType val_type, void* val)
			{
				vectors.av_opt_set_array = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_array_delegate>("avutil", "av_opt_set_array", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_array_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_array(obj, name, search_flags, start_elem, nb_elems, val_type, val);
			};
			vectors.av_opt_set_bin = delegate(void* obj, string name, byte* val, int size, int search_flags)
			{
				vectors.av_opt_set_bin = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_bin_delegate>("avutil", "av_opt_set_bin", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_bin_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_bin(obj, name, val, size, search_flags);
			};
			vectors.av_opt_set_chlayout = delegate(void* obj, string name, AVChannelLayout* layout, int search_flags)
			{
				vectors.av_opt_set_chlayout = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_chlayout_delegate>("avutil", "av_opt_set_chlayout", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_chlayout_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_chlayout(obj, name, layout, search_flags);
			};
			vectors.av_opt_set_defaults = delegate(void* s)
			{
				vectors.av_opt_set_defaults = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_defaults_delegate>("avutil", "av_opt_set_defaults", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_defaults_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_opt_set_defaults(s);
			};
			vectors.av_opt_set_defaults2 = delegate(void* s, int mask, int flags)
			{
				vectors.av_opt_set_defaults2 = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_defaults2_delegate>("avutil", "av_opt_set_defaults2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_defaults2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_opt_set_defaults2(s, mask, flags);
			};
			vectors.av_opt_set_dict = delegate(void* obj, AVDictionary** options)
			{
				vectors.av_opt_set_dict = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_dict_delegate>("avutil", "av_opt_set_dict", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_dict_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_dict(obj, options);
			};
			vectors.av_opt_set_dict_val = delegate(void* obj, string name, AVDictionary* val, int search_flags)
			{
				vectors.av_opt_set_dict_val = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_dict_val_delegate>("avutil", "av_opt_set_dict_val", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_dict_val_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_dict_val(obj, name, val, search_flags);
			};
			vectors.av_opt_set_dict2 = delegate(void* obj, AVDictionary** options, int search_flags)
			{
				vectors.av_opt_set_dict2 = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_dict2_delegate>("avutil", "av_opt_set_dict2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_dict2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_dict2(obj, options, search_flags);
			};
			vectors.av_opt_set_double = delegate(void* obj, string name, double val, int search_flags)
			{
				vectors.av_opt_set_double = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_double_delegate>("avutil", "av_opt_set_double", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_double_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_double(obj, name, val, search_flags);
			};
			vectors.av_opt_set_from_string = delegate(void* ctx, string opts, byte** shorthand, string key_val_sep, string pairs_sep)
			{
				vectors.av_opt_set_from_string = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_from_string_delegate>("avutil", "av_opt_set_from_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_from_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_from_string(ctx, opts, shorthand, key_val_sep, pairs_sep);
			};
			vectors.av_opt_set_image_size = delegate(void* obj, string name, int w, int h, int search_flags)
			{
				vectors.av_opt_set_image_size = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_image_size_delegate>("avutil", "av_opt_set_image_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_image_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_image_size(obj, name, w, h, search_flags);
			};
			vectors.av_opt_set_int = delegate(void* obj, string name, long val, int search_flags)
			{
				vectors.av_opt_set_int = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_int_delegate>("avutil", "av_opt_set_int", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_int_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_int(obj, name, val, search_flags);
			};
			vectors.av_opt_set_pixel_fmt = delegate(void* obj, string name, AVPixelFormat fmt, int search_flags)
			{
				vectors.av_opt_set_pixel_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_pixel_fmt_delegate>("avutil", "av_opt_set_pixel_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_pixel_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_pixel_fmt(obj, name, fmt, search_flags);
			};
			vectors.av_opt_set_q = delegate(void* obj, string name, AVRational val, int search_flags)
			{
				vectors.av_opt_set_q = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_q_delegate>("avutil", "av_opt_set_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_q(obj, name, val, search_flags);
			};
			vectors.av_opt_set_sample_fmt = delegate(void* obj, string name, AVSampleFormat fmt, int search_flags)
			{
				vectors.av_opt_set_sample_fmt = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_sample_fmt_delegate>("avutil", "av_opt_set_sample_fmt", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_sample_fmt_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_sample_fmt(obj, name, fmt, search_flags);
			};
			vectors.av_opt_set_video_rate = delegate(void* obj, string name, AVRational val, int search_flags)
			{
				vectors.av_opt_set_video_rate = FunctionResolver.GetFunctionDelegate<vectors.av_opt_set_video_rate_delegate>("avutil", "av_opt_set_video_rate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_set_video_rate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_set_video_rate(obj, name, val, search_flags);
			};
			vectors.av_opt_show2 = delegate(void* obj, void* av_log_obj, int req_flags, int rej_flags)
			{
				vectors.av_opt_show2 = FunctionResolver.GetFunctionDelegate<vectors.av_opt_show2_delegate>("avutil", "av_opt_show2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_opt_show2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_opt_show2(obj, av_log_obj, req_flags, rej_flags);
			};
			vectors.av_output_audio_device_next = delegate(AVOutputFormat* d)
			{
				vectors.av_output_audio_device_next = FunctionResolver.GetFunctionDelegate<vectors.av_output_audio_device_next_delegate>("avdevice", "av_output_audio_device_next", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_output_audio_device_next_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_output_audio_device_next(d);
			};
			vectors.av_output_video_device_next = delegate(AVOutputFormat* d)
			{
				vectors.av_output_video_device_next = FunctionResolver.GetFunctionDelegate<vectors.av_output_video_device_next_delegate>("avdevice", "av_output_video_device_next", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_output_video_device_next_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_output_video_device_next(d);
			};
			vectors.av_packet_add_side_data = delegate(AVPacket* pkt, AVPacketSideDataType type, byte* data, ulong size)
			{
				vectors.av_packet_add_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_packet_add_side_data_delegate>("avcodec", "av_packet_add_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_add_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_add_side_data(pkt, type, data, size);
			};
			vectors.av_packet_alloc = delegate
			{
				vectors.av_packet_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_packet_alloc_delegate>("avcodec", "av_packet_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_alloc();
			};
			vectors.av_packet_clone = delegate(AVPacket* src)
			{
				vectors.av_packet_clone = FunctionResolver.GetFunctionDelegate<vectors.av_packet_clone_delegate>("avcodec", "av_packet_clone", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_clone_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_clone(src);
			};
			vectors.av_packet_copy_props = delegate(AVPacket* dst, AVPacket* src)
			{
				vectors.av_packet_copy_props = FunctionResolver.GetFunctionDelegate<vectors.av_packet_copy_props_delegate>("avcodec", "av_packet_copy_props", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_copy_props_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_copy_props(dst, src);
			};
			vectors.av_packet_free = delegate(AVPacket** pkt)
			{
				vectors.av_packet_free = FunctionResolver.GetFunctionDelegate<vectors.av_packet_free_delegate>("avcodec", "av_packet_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_packet_free(pkt);
			};
			vectors.av_packet_free_side_data = delegate(AVPacket* pkt)
			{
				vectors.av_packet_free_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_packet_free_side_data_delegate>("avcodec", "av_packet_free_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_free_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_packet_free_side_data(pkt);
			};
			vectors.av_packet_from_data = delegate(AVPacket* pkt, byte* data, int size)
			{
				vectors.av_packet_from_data = FunctionResolver.GetFunctionDelegate<vectors.av_packet_from_data_delegate>("avcodec", "av_packet_from_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_from_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_from_data(pkt, data, size);
			};
			vectors.av_packet_get_side_data = delegate(AVPacket* pkt, AVPacketSideDataType type, ulong* size)
			{
				vectors.av_packet_get_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_packet_get_side_data_delegate>("avcodec", "av_packet_get_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_get_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_get_side_data(pkt, type, size);
			};
			vectors.av_packet_make_refcounted = delegate(AVPacket* pkt)
			{
				vectors.av_packet_make_refcounted = FunctionResolver.GetFunctionDelegate<vectors.av_packet_make_refcounted_delegate>("avcodec", "av_packet_make_refcounted", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_make_refcounted_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_make_refcounted(pkt);
			};
			vectors.av_packet_make_writable = delegate(AVPacket* pkt)
			{
				vectors.av_packet_make_writable = FunctionResolver.GetFunctionDelegate<vectors.av_packet_make_writable_delegate>("avcodec", "av_packet_make_writable", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_make_writable_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_make_writable(pkt);
			};
			vectors.av_packet_move_ref = delegate(AVPacket* dst, AVPacket* src)
			{
				vectors.av_packet_move_ref = FunctionResolver.GetFunctionDelegate<vectors.av_packet_move_ref_delegate>("avcodec", "av_packet_move_ref", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_move_ref_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_packet_move_ref(dst, src);
			};
			vectors.av_packet_new_side_data = delegate(AVPacket* pkt, AVPacketSideDataType type, ulong size)
			{
				vectors.av_packet_new_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_packet_new_side_data_delegate>("avcodec", "av_packet_new_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_new_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_new_side_data(pkt, type, size);
			};
			vectors.av_packet_pack_dictionary = delegate(AVDictionary* dict, ulong* size)
			{
				vectors.av_packet_pack_dictionary = FunctionResolver.GetFunctionDelegate<vectors.av_packet_pack_dictionary_delegate>("avcodec", "av_packet_pack_dictionary", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_pack_dictionary_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_pack_dictionary(dict, size);
			};
			vectors.av_packet_ref = delegate(AVPacket* dst, AVPacket* src)
			{
				vectors.av_packet_ref = FunctionResolver.GetFunctionDelegate<vectors.av_packet_ref_delegate>("avcodec", "av_packet_ref", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_ref_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_ref(dst, src);
			};
			vectors.av_packet_rescale_ts = delegate(AVPacket* pkt, AVRational tb_src, AVRational tb_dst)
			{
				vectors.av_packet_rescale_ts = FunctionResolver.GetFunctionDelegate<vectors.av_packet_rescale_ts_delegate>("avcodec", "av_packet_rescale_ts", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_rescale_ts_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_packet_rescale_ts(pkt, tb_src, tb_dst);
			};
			vectors.av_packet_shrink_side_data = delegate(AVPacket* pkt, AVPacketSideDataType type, ulong size)
			{
				vectors.av_packet_shrink_side_data = FunctionResolver.GetFunctionDelegate<vectors.av_packet_shrink_side_data_delegate>("avcodec", "av_packet_shrink_side_data", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_shrink_side_data_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_shrink_side_data(pkt, type, size);
			};
			vectors.av_packet_side_data_add = delegate(AVPacketSideData** sd, int* nb_sd, AVPacketSideDataType type, void* data, ulong size, int flags)
			{
				vectors.av_packet_side_data_add = FunctionResolver.GetFunctionDelegate<vectors.av_packet_side_data_add_delegate>("avcodec", "av_packet_side_data_add", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_side_data_add_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_side_data_add(sd, nb_sd, type, data, size, flags);
			};
			vectors.av_packet_side_data_free = delegate(AVPacketSideData** sd, int* nb_sd)
			{
				vectors.av_packet_side_data_free = FunctionResolver.GetFunctionDelegate<vectors.av_packet_side_data_free_delegate>("avcodec", "av_packet_side_data_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_side_data_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_packet_side_data_free(sd, nb_sd);
			};
			vectors.av_packet_side_data_get = delegate(AVPacketSideData* sd, int nb_sd, AVPacketSideDataType type)
			{
				vectors.av_packet_side_data_get = FunctionResolver.GetFunctionDelegate<vectors.av_packet_side_data_get_delegate>("avcodec", "av_packet_side_data_get", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_side_data_get_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_side_data_get(sd, nb_sd, type);
			};
			vectors.av_packet_side_data_name = delegate(AVPacketSideDataType type)
			{
				vectors.av_packet_side_data_name = FunctionResolver.GetFunctionDelegate<vectors.av_packet_side_data_name_delegate>("avcodec", "av_packet_side_data_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_side_data_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_side_data_name(type);
			};
			vectors.av_packet_side_data_new = delegate(AVPacketSideData** psd, int* pnb_sd, AVPacketSideDataType type, ulong size, int flags)
			{
				vectors.av_packet_side_data_new = FunctionResolver.GetFunctionDelegate<vectors.av_packet_side_data_new_delegate>("avcodec", "av_packet_side_data_new", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_side_data_new_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_side_data_new(psd, pnb_sd, type, size, flags);
			};
			vectors.av_packet_side_data_remove = delegate(AVPacketSideData* sd, int* nb_sd, AVPacketSideDataType type)
			{
				vectors.av_packet_side_data_remove = FunctionResolver.GetFunctionDelegate<vectors.av_packet_side_data_remove_delegate>("avcodec", "av_packet_side_data_remove", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_side_data_remove_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_packet_side_data_remove(sd, nb_sd, type);
			};
			vectors.av_packet_unpack_dictionary = delegate(byte* data, ulong size, AVDictionary** dict)
			{
				vectors.av_packet_unpack_dictionary = FunctionResolver.GetFunctionDelegate<vectors.av_packet_unpack_dictionary_delegate>("avcodec", "av_packet_unpack_dictionary", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_unpack_dictionary_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_packet_unpack_dictionary(data, size, dict);
			};
			vectors.av_packet_unref = delegate(AVPacket* pkt)
			{
				vectors.av_packet_unref = FunctionResolver.GetFunctionDelegate<vectors.av_packet_unref_delegate>("avcodec", "av_packet_unref", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_packet_unref_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_packet_unref(pkt);
			};
			vectors.av_parse_cpu_caps = delegate(uint* flags, string s)
			{
				vectors.av_parse_cpu_caps = FunctionResolver.GetFunctionDelegate<vectors.av_parse_cpu_caps_delegate>("avutil", "av_parse_cpu_caps", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_parse_cpu_caps_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_parse_cpu_caps(flags, s);
			};
			vectors.av_parser_close = delegate(AVCodecParserContext* s)
			{
				vectors.av_parser_close = FunctionResolver.GetFunctionDelegate<vectors.av_parser_close_delegate>("avcodec", "av_parser_close", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_parser_close_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_parser_close(s);
			};
			vectors.av_parser_init = delegate(int codec_id)
			{
				vectors.av_parser_init = FunctionResolver.GetFunctionDelegate<vectors.av_parser_init_delegate>("avcodec", "av_parser_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_parser_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_parser_init(codec_id);
			};
			vectors.av_parser_iterate = delegate(void** opaque)
			{
				vectors.av_parser_iterate = FunctionResolver.GetFunctionDelegate<vectors.av_parser_iterate_delegate>("avcodec", "av_parser_iterate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_parser_iterate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_parser_iterate(opaque);
			};
			vectors.av_parser_parse2 = delegate(AVCodecParserContext* s, AVCodecContext* avctx, byte** poutbuf, int* poutbuf_size, byte* buf, int buf_size, long pts, long dts, long pos)
			{
				vectors.av_parser_parse2 = FunctionResolver.GetFunctionDelegate<vectors.av_parser_parse2_delegate>("avcodec", "av_parser_parse2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_parser_parse2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_parser_parse2(s, avctx, poutbuf, poutbuf_size, buf, buf_size, pts, dts, pos);
			};
			vectors.av_pix_fmt_count_planes = delegate(AVPixelFormat pix_fmt)
			{
				vectors.av_pix_fmt_count_planes = FunctionResolver.GetFunctionDelegate<vectors.av_pix_fmt_count_planes_delegate>("avutil", "av_pix_fmt_count_planes", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_pix_fmt_count_planes_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_pix_fmt_count_planes(pix_fmt);
			};
			vectors.av_pix_fmt_desc_get = delegate(AVPixelFormat pix_fmt)
			{
				vectors.av_pix_fmt_desc_get = FunctionResolver.GetFunctionDelegate<vectors.av_pix_fmt_desc_get_delegate>("avutil", "av_pix_fmt_desc_get", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_pix_fmt_desc_get_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_pix_fmt_desc_get(pix_fmt);
			};
			vectors.av_pix_fmt_desc_get_id = delegate(AVPixFmtDescriptor* desc)
			{
				vectors.av_pix_fmt_desc_get_id = FunctionResolver.GetFunctionDelegate<vectors.av_pix_fmt_desc_get_id_delegate>("avutil", "av_pix_fmt_desc_get_id", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_pix_fmt_desc_get_id_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_pix_fmt_desc_get_id(desc);
			};
			vectors.av_pix_fmt_desc_next = delegate(AVPixFmtDescriptor* prev)
			{
				vectors.av_pix_fmt_desc_next = FunctionResolver.GetFunctionDelegate<vectors.av_pix_fmt_desc_next_delegate>("avutil", "av_pix_fmt_desc_next", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_pix_fmt_desc_next_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_pix_fmt_desc_next(prev);
			};
			vectors.av_pix_fmt_get_chroma_sub_sample = delegate(AVPixelFormat pix_fmt, int* h_shift, int* v_shift)
			{
				vectors.av_pix_fmt_get_chroma_sub_sample = FunctionResolver.GetFunctionDelegate<vectors.av_pix_fmt_get_chroma_sub_sample_delegate>("avutil", "av_pix_fmt_get_chroma_sub_sample", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_pix_fmt_get_chroma_sub_sample_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_pix_fmt_get_chroma_sub_sample(pix_fmt, h_shift, v_shift);
			};
			vectors.av_pix_fmt_swap_endianness = delegate(AVPixelFormat pix_fmt)
			{
				vectors.av_pix_fmt_swap_endianness = FunctionResolver.GetFunctionDelegate<vectors.av_pix_fmt_swap_endianness_delegate>("avutil", "av_pix_fmt_swap_endianness", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_pix_fmt_swap_endianness_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_pix_fmt_swap_endianness(pix_fmt);
			};
			vectors.av_pkt_dump_log2 = delegate(void* avcl, int level, AVPacket* pkt, int dump_payload, AVStream* st)
			{
				vectors.av_pkt_dump_log2 = FunctionResolver.GetFunctionDelegate<vectors.av_pkt_dump_log2_delegate>("avformat", "av_pkt_dump_log2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_pkt_dump_log2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_pkt_dump_log2(avcl, level, pkt, dump_payload, st);
			};
			vectors.av_pkt_dump2 = delegate(_iobuf* f, AVPacket* pkt, int dump_payload, AVStream* st)
			{
				vectors.av_pkt_dump2 = FunctionResolver.GetFunctionDelegate<vectors.av_pkt_dump2_delegate>("avformat", "av_pkt_dump2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_pkt_dump2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_pkt_dump2(f, pkt, dump_payload, st);
			};
			vectors.av_probe_input_buffer = delegate(AVIOContext* pb, AVInputFormat** fmt, string url, void* logctx, uint offset, uint max_probe_size)
			{
				vectors.av_probe_input_buffer = FunctionResolver.GetFunctionDelegate<vectors.av_probe_input_buffer_delegate>("avformat", "av_probe_input_buffer", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_probe_input_buffer_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_probe_input_buffer(pb, fmt, url, logctx, offset, max_probe_size);
			};
			vectors.av_probe_input_buffer2 = delegate(AVIOContext* pb, AVInputFormat** fmt, string url, void* logctx, uint offset, uint max_probe_size)
			{
				vectors.av_probe_input_buffer2 = FunctionResolver.GetFunctionDelegate<vectors.av_probe_input_buffer2_delegate>("avformat", "av_probe_input_buffer2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_probe_input_buffer2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_probe_input_buffer2(pb, fmt, url, logctx, offset, max_probe_size);
			};
			vectors.av_probe_input_format = delegate(AVProbeData* pd, int is_opened)
			{
				vectors.av_probe_input_format = FunctionResolver.GetFunctionDelegate<vectors.av_probe_input_format_delegate>("avformat", "av_probe_input_format", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_probe_input_format_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_probe_input_format(pd, is_opened);
			};
			vectors.av_probe_input_format2 = delegate(AVProbeData* pd, int is_opened, int* score_max)
			{
				vectors.av_probe_input_format2 = FunctionResolver.GetFunctionDelegate<vectors.av_probe_input_format2_delegate>("avformat", "av_probe_input_format2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_probe_input_format2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_probe_input_format2(pd, is_opened, score_max);
			};
			vectors.av_probe_input_format3 = delegate(AVProbeData* pd, int is_opened, int* score_ret)
			{
				vectors.av_probe_input_format3 = FunctionResolver.GetFunctionDelegate<vectors.av_probe_input_format3_delegate>("avformat", "av_probe_input_format3", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_probe_input_format3_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_probe_input_format3(pd, is_opened, score_ret);
			};
			vectors.av_program_add_stream_index = delegate(AVFormatContext* ac, int progid, uint idx)
			{
				vectors.av_program_add_stream_index = FunctionResolver.GetFunctionDelegate<vectors.av_program_add_stream_index_delegate>("avformat", "av_program_add_stream_index", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_program_add_stream_index_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_program_add_stream_index(ac, progid, idx);
			};
			vectors.av_q2intfloat = delegate(AVRational q)
			{
				vectors.av_q2intfloat = FunctionResolver.GetFunctionDelegate<vectors.av_q2intfloat_delegate>("avutil", "av_q2intfloat", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_q2intfloat_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_q2intfloat(q);
			};
			vectors.av_read_frame = delegate(AVFormatContext* s, AVPacket* pkt)
			{
				vectors.av_read_frame = FunctionResolver.GetFunctionDelegate<vectors.av_read_frame_delegate>("avformat", "av_read_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_read_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_read_frame(s, pkt);
			};
			vectors.av_read_image_line = delegate(ushort* dst, in byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int read_pal_component)
			{
				vectors.av_read_image_line = FunctionResolver.GetFunctionDelegate<vectors.av_read_image_line_delegate>("avutil", "av_read_image_line", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_read_image_line_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_read_image_line(dst, in data, in linesize, desc, x, y, c, w, read_pal_component);
			};
			vectors.av_read_image_line2 = delegate(void* dst, in byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int read_pal_component, int dst_element_size)
			{
				vectors.av_read_image_line2 = FunctionResolver.GetFunctionDelegate<vectors.av_read_image_line2_delegate>("avutil", "av_read_image_line2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_read_image_line2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_read_image_line2(dst, in data, in linesize, desc, x, y, c, w, read_pal_component, dst_element_size);
			};
			vectors.av_read_pause = delegate(AVFormatContext* s)
			{
				vectors.av_read_pause = FunctionResolver.GetFunctionDelegate<vectors.av_read_pause_delegate>("avformat", "av_read_pause", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_read_pause_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_read_pause(s);
			};
			vectors.av_read_play = delegate(AVFormatContext* s)
			{
				vectors.av_read_play = FunctionResolver.GetFunctionDelegate<vectors.av_read_play_delegate>("avformat", "av_read_play", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_read_play_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_read_play(s);
			};
			vectors.av_realloc = delegate(void* ptr, ulong size)
			{
				vectors.av_realloc = FunctionResolver.GetFunctionDelegate<vectors.av_realloc_delegate>("avutil", "av_realloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_realloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_realloc(ptr, size);
			};
			vectors.av_realloc_array = delegate(void* ptr, ulong nmemb, ulong size)
			{
				vectors.av_realloc_array = FunctionResolver.GetFunctionDelegate<vectors.av_realloc_array_delegate>("avutil", "av_realloc_array", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_realloc_array_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_realloc_array(ptr, nmemb, size);
			};
			vectors.av_realloc_f = delegate(void* ptr, ulong nelem, ulong elsize)
			{
				vectors.av_realloc_f = FunctionResolver.GetFunctionDelegate<vectors.av_realloc_f_delegate>("avutil", "av_realloc_f", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_realloc_f_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_realloc_f(ptr, nelem, elsize);
			};
			vectors.av_reallocp = delegate(void* ptr, ulong size)
			{
				vectors.av_reallocp = FunctionResolver.GetFunctionDelegate<vectors.av_reallocp_delegate>("avutil", "av_reallocp", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_reallocp_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_reallocp(ptr, size);
			};
			vectors.av_reallocp_array = delegate(void* ptr, ulong nmemb, ulong size)
			{
				vectors.av_reallocp_array = FunctionResolver.GetFunctionDelegate<vectors.av_reallocp_array_delegate>("avutil", "av_reallocp_array", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_reallocp_array_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_reallocp_array(ptr, nmemb, size);
			};
			vectors.av_reduce = delegate(int* dst_num, int* dst_den, long num, long den, long max)
			{
				vectors.av_reduce = FunctionResolver.GetFunctionDelegate<vectors.av_reduce_delegate>("avutil", "av_reduce", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_reduce_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_reduce(dst_num, dst_den, num, den, max);
			};
			vectors.av_rescale = delegate(long a, long b, long c)
			{
				vectors.av_rescale = FunctionResolver.GetFunctionDelegate<vectors.av_rescale_delegate>("avutil", "av_rescale", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_rescale_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_rescale(a, b, c);
			};
			vectors.av_rescale_delta = delegate(AVRational in_tb, long in_ts, AVRational fs_tb, int duration, long* last, AVRational out_tb)
			{
				vectors.av_rescale_delta = FunctionResolver.GetFunctionDelegate<vectors.av_rescale_delta_delegate>("avutil", "av_rescale_delta", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_rescale_delta_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_rescale_delta(in_tb, in_ts, fs_tb, duration, last, out_tb);
			};
			vectors.av_rescale_q = delegate(long a, AVRational bq, AVRational cq)
			{
				vectors.av_rescale_q = FunctionResolver.GetFunctionDelegate<vectors.av_rescale_q_delegate>("avutil", "av_rescale_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_rescale_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_rescale_q(a, bq, cq);
			};
			vectors.av_rescale_q_rnd = delegate(long a, AVRational bq, AVRational cq, AVRounding rnd)
			{
				vectors.av_rescale_q_rnd = FunctionResolver.GetFunctionDelegate<vectors.av_rescale_q_rnd_delegate>("avutil", "av_rescale_q_rnd", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_rescale_q_rnd_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_rescale_q_rnd(a, bq, cq, rnd);
			};
			vectors.av_rescale_rnd = delegate(long a, long b, long c, AVRounding rnd)
			{
				vectors.av_rescale_rnd = FunctionResolver.GetFunctionDelegate<vectors.av_rescale_rnd_delegate>("avutil", "av_rescale_rnd", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_rescale_rnd_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_rescale_rnd(a, b, c, rnd);
			};
			vectors.av_sample_fmt_is_planar = delegate(AVSampleFormat sample_fmt)
			{
				vectors.av_sample_fmt_is_planar = FunctionResolver.GetFunctionDelegate<vectors.av_sample_fmt_is_planar_delegate>("avutil", "av_sample_fmt_is_planar", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_sample_fmt_is_planar_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_sample_fmt_is_planar(sample_fmt);
			};
			vectors.av_samples_alloc = delegate(byte** audio_data, int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)
			{
				vectors.av_samples_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_samples_alloc_delegate>("avutil", "av_samples_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_samples_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_samples_alloc(audio_data, linesize, nb_channels, nb_samples, sample_fmt, align);
			};
			vectors.av_samples_alloc_array_and_samples = delegate(byte*** audio_data, int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)
			{
				vectors.av_samples_alloc_array_and_samples = FunctionResolver.GetFunctionDelegate<vectors.av_samples_alloc_array_and_samples_delegate>("avutil", "av_samples_alloc_array_and_samples", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_samples_alloc_array_and_samples_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_samples_alloc_array_and_samples(audio_data, linesize, nb_channels, nb_samples, sample_fmt, align);
			};
			vectors.av_samples_copy = delegate(byte** dst, byte** src, int dst_offset, int src_offset, int nb_samples, int nb_channels, AVSampleFormat sample_fmt)
			{
				vectors.av_samples_copy = FunctionResolver.GetFunctionDelegate<vectors.av_samples_copy_delegate>("avutil", "av_samples_copy", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_samples_copy_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_samples_copy(dst, src, dst_offset, src_offset, nb_samples, nb_channels, sample_fmt);
			};
			vectors.av_samples_fill_arrays = delegate(byte** audio_data, int* linesize, byte* buf, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)
			{
				vectors.av_samples_fill_arrays = FunctionResolver.GetFunctionDelegate<vectors.av_samples_fill_arrays_delegate>("avutil", "av_samples_fill_arrays", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_samples_fill_arrays_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_samples_fill_arrays(audio_data, linesize, buf, nb_channels, nb_samples, sample_fmt, align);
			};
			vectors.av_samples_get_buffer_size = delegate(int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)
			{
				vectors.av_samples_get_buffer_size = FunctionResolver.GetFunctionDelegate<vectors.av_samples_get_buffer_size_delegate>("avutil", "av_samples_get_buffer_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_samples_get_buffer_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_samples_get_buffer_size(linesize, nb_channels, nb_samples, sample_fmt, align);
			};
			vectors.av_samples_set_silence = delegate(byte** audio_data, int offset, int nb_samples, int nb_channels, AVSampleFormat sample_fmt)
			{
				vectors.av_samples_set_silence = FunctionResolver.GetFunctionDelegate<vectors.av_samples_set_silence_delegate>("avutil", "av_samples_set_silence", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_samples_set_silence_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_samples_set_silence(audio_data, offset, nb_samples, nb_channels, sample_fmt);
			};
			vectors.av_sdp_create = delegate(AVFormatContext** ac, int n_files, byte* buf, int size)
			{
				vectors.av_sdp_create = FunctionResolver.GetFunctionDelegate<vectors.av_sdp_create_delegate>("avformat", "av_sdp_create", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_sdp_create_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_sdp_create(ac, n_files, buf, size);
			};
			vectors.av_seek_frame = delegate(AVFormatContext* s, int stream_index, long timestamp, int flags)
			{
				vectors.av_seek_frame = FunctionResolver.GetFunctionDelegate<vectors.av_seek_frame_delegate>("avformat", "av_seek_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_seek_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_seek_frame(s, stream_index, timestamp, flags);
			};
			vectors.av_set_options_string = delegate(void* ctx, string opts, string key_val_sep, string pairs_sep)
			{
				vectors.av_set_options_string = FunctionResolver.GetFunctionDelegate<vectors.av_set_options_string_delegate>("avutil", "av_set_options_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_set_options_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_set_options_string(ctx, opts, key_val_sep, pairs_sep);
			};
			vectors.av_shrink_packet = delegate(AVPacket* pkt, int size)
			{
				vectors.av_shrink_packet = FunctionResolver.GetFunctionDelegate<vectors.av_shrink_packet_delegate>("avcodec", "av_shrink_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_shrink_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_shrink_packet(pkt, size);
			};
			vectors.av_size_mult = delegate(ulong a, ulong b, ulong* r)
			{
				vectors.av_size_mult = FunctionResolver.GetFunctionDelegate<vectors.av_size_mult_delegate>("avutil", "av_size_mult", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_size_mult_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_size_mult(a, b, r);
			};
			vectors.av_strdup = delegate(string s)
			{
				vectors.av_strdup = FunctionResolver.GetFunctionDelegate<vectors.av_strdup_delegate>("avutil", "av_strdup", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_strdup_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_strdup(s);
			};
			vectors.av_stream_get_class = delegate
			{
				vectors.av_stream_get_class = FunctionResolver.GetFunctionDelegate<vectors.av_stream_get_class_delegate>("avformat", "av_stream_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_stream_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_stream_get_class();
			};
			vectors.av_stream_get_codec_timebase = delegate(AVStream* st)
			{
				vectors.av_stream_get_codec_timebase = FunctionResolver.GetFunctionDelegate<vectors.av_stream_get_codec_timebase_delegate>("avformat", "av_stream_get_codec_timebase", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_stream_get_codec_timebase_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_stream_get_codec_timebase(st);
			};
			vectors.av_stream_get_parser = delegate(AVStream* s)
			{
				vectors.av_stream_get_parser = FunctionResolver.GetFunctionDelegate<vectors.av_stream_get_parser_delegate>("avformat", "av_stream_get_parser", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_stream_get_parser_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_stream_get_parser(s);
			};
			vectors.av_stream_group_get_class = delegate
			{
				vectors.av_stream_group_get_class = FunctionResolver.GetFunctionDelegate<vectors.av_stream_group_get_class_delegate>("avformat", "av_stream_group_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_stream_group_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_stream_group_get_class();
			};
			vectors.av_strerror = delegate(int errnum, byte* errbuf, ulong errbuf_size)
			{
				vectors.av_strerror = FunctionResolver.GetFunctionDelegate<vectors.av_strerror_delegate>("avutil", "av_strerror", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_strerror_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_strerror(errnum, errbuf, errbuf_size);
			};
			vectors.av_strndup = delegate(string s, ulong len)
			{
				vectors.av_strndup = FunctionResolver.GetFunctionDelegate<vectors.av_strndup_delegate>("avutil", "av_strndup", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_strndup_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_strndup(s, len);
			};
			vectors.av_sub_q = delegate(AVRational b, AVRational c)
			{
				vectors.av_sub_q = FunctionResolver.GetFunctionDelegate<vectors.av_sub_q_delegate>("avutil", "av_sub_q", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_sub_q_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_sub_q(b, c);
			};
			vectors.av_timecode_adjust_ntsc_framenum2 = delegate(int framenum, int fps)
			{
				vectors.av_timecode_adjust_ntsc_framenum2 = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_adjust_ntsc_framenum2_delegate>("avutil", "av_timecode_adjust_ntsc_framenum2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_adjust_ntsc_framenum2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_adjust_ntsc_framenum2(framenum, fps);
			};
			vectors.av_timecode_check_frame_rate = delegate(AVRational rate)
			{
				vectors.av_timecode_check_frame_rate = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_check_frame_rate_delegate>("avutil", "av_timecode_check_frame_rate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_check_frame_rate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_check_frame_rate(rate);
			};
			vectors.av_timecode_get_smpte = delegate(AVRational rate, int drop, int hh, int mm, int ss, int ff)
			{
				vectors.av_timecode_get_smpte = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_get_smpte_delegate>("avutil", "av_timecode_get_smpte", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_get_smpte_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_get_smpte(rate, drop, hh, mm, ss, ff);
			};
			vectors.av_timecode_get_smpte_from_framenum = delegate(AVTimecode* tc, int framenum)
			{
				vectors.av_timecode_get_smpte_from_framenum = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_get_smpte_from_framenum_delegate>("avutil", "av_timecode_get_smpte_from_framenum", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_get_smpte_from_framenum_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_get_smpte_from_framenum(tc, framenum);
			};
			vectors.av_timecode_init = delegate(AVTimecode* tc, AVRational rate, int flags, int frame_start, void* log_ctx)
			{
				vectors.av_timecode_init = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_init_delegate>("avutil", "av_timecode_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_init(tc, rate, flags, frame_start, log_ctx);
			};
			vectors.av_timecode_init_from_components = delegate(AVTimecode* tc, AVRational rate, int flags, int hh, int mm, int ss, int ff, void* log_ctx)
			{
				vectors.av_timecode_init_from_components = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_init_from_components_delegate>("avutil", "av_timecode_init_from_components", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_init_from_components_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_init_from_components(tc, rate, flags, hh, mm, ss, ff, log_ctx);
			};
			vectors.av_timecode_init_from_string = delegate(AVTimecode* tc, AVRational rate, string str, void* log_ctx)
			{
				vectors.av_timecode_init_from_string = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_init_from_string_delegate>("avutil", "av_timecode_init_from_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_init_from_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_init_from_string(tc, rate, str, log_ctx);
			};
			vectors.av_timecode_make_mpeg_tc_string = delegate(byte* buf, uint tc25bit)
			{
				vectors.av_timecode_make_mpeg_tc_string = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_make_mpeg_tc_string_delegate>("avutil", "av_timecode_make_mpeg_tc_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_make_mpeg_tc_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_make_mpeg_tc_string(buf, tc25bit);
			};
			vectors.av_timecode_make_smpte_tc_string = delegate(byte* buf, uint tcsmpte, int prevent_df)
			{
				vectors.av_timecode_make_smpte_tc_string = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_make_smpte_tc_string_delegate>("avutil", "av_timecode_make_smpte_tc_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_make_smpte_tc_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_make_smpte_tc_string(buf, tcsmpte, prevent_df);
			};
			vectors.av_timecode_make_smpte_tc_string2 = delegate(byte* buf, AVRational rate, uint tcsmpte, int prevent_df, int skip_field)
			{
				vectors.av_timecode_make_smpte_tc_string2 = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_make_smpte_tc_string2_delegate>("avutil", "av_timecode_make_smpte_tc_string2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_make_smpte_tc_string2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_make_smpte_tc_string2(buf, rate, tcsmpte, prevent_df, skip_field);
			};
			vectors.av_timecode_make_string = delegate(AVTimecode* tc, byte* buf, int framenum)
			{
				vectors.av_timecode_make_string = FunctionResolver.GetFunctionDelegate<vectors.av_timecode_make_string_delegate>("avutil", "av_timecode_make_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_timecode_make_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_timecode_make_string(tc, buf, framenum);
			};
			vectors.av_tree_destroy = delegate(AVTreeNode* t)
			{
				vectors.av_tree_destroy = FunctionResolver.GetFunctionDelegate<vectors.av_tree_destroy_delegate>("avutil", "av_tree_destroy", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_tree_destroy_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_tree_destroy(t);
			};
			vectors.av_tree_enumerate = delegate(AVTreeNode* t, void* opaque, av_tree_enumerate_cmp_func cmp, av_tree_enumerate_enu_func enu)
			{
				vectors.av_tree_enumerate = FunctionResolver.GetFunctionDelegate<vectors.av_tree_enumerate_delegate>("avutil", "av_tree_enumerate", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_tree_enumerate_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_tree_enumerate(t, opaque, cmp, enu);
			};
			vectors.av_tree_find = delegate(AVTreeNode* root, void* key, av_tree_find_cmp_func cmp, ref void_ptrArray2 next)
			{
				vectors.av_tree_find = FunctionResolver.GetFunctionDelegate<vectors.av_tree_find_delegate>("avutil", "av_tree_find", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_tree_find_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_tree_find(root, key, cmp, ref next);
			};
			vectors.av_tree_insert = delegate(AVTreeNode** rootp, void* key, av_tree_insert_cmp_func cmp, AVTreeNode** next)
			{
				vectors.av_tree_insert = FunctionResolver.GetFunctionDelegate<vectors.av_tree_insert_delegate>("avutil", "av_tree_insert", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_tree_insert_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_tree_insert(rootp, key, cmp, next);
			};
			vectors.av_tree_node_alloc = delegate
			{
				vectors.av_tree_node_alloc = FunctionResolver.GetFunctionDelegate<vectors.av_tree_node_alloc_delegate>("avutil", "av_tree_node_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_tree_node_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_tree_node_alloc();
			};
			vectors.av_url_split = delegate(byte* proto, int proto_size, byte* authorization, int authorization_size, byte* hostname, int hostname_size, int* port_ptr, byte* path, int path_size, string url)
			{
				vectors.av_url_split = FunctionResolver.GetFunctionDelegate<vectors.av_url_split_delegate>("avformat", "av_url_split", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_url_split_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_url_split(proto, proto_size, authorization, authorization_size, hostname, hostname_size, port_ptr, path, path_size, url);
			};
			vectors.av_usleep = delegate(uint usec)
			{
				vectors.av_usleep = FunctionResolver.GetFunctionDelegate<vectors.av_usleep_delegate>("avutil", "av_usleep", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_usleep_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_usleep(usec);
			};
			vectors.av_version_info = delegate
			{
				vectors.av_version_info = FunctionResolver.GetFunctionDelegate<vectors.av_version_info_delegate>("avutil", "av_version_info", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_version_info_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_version_info();
			};
			vectors.av_vlog = delegate(void* avcl, int level, string fmt, byte* vl)
			{
				vectors.av_vlog = FunctionResolver.GetFunctionDelegate<vectors.av_vlog_delegate>("avutil", "av_vlog", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_vlog_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_vlog(avcl, level, fmt, vl);
			};
			vectors.av_write_frame = delegate(AVFormatContext* s, AVPacket* pkt)
			{
				vectors.av_write_frame = FunctionResolver.GetFunctionDelegate<vectors.av_write_frame_delegate>("avformat", "av_write_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_write_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_write_frame(s, pkt);
			};
			vectors.av_write_image_line = delegate(ushort* src, ref byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w)
			{
				vectors.av_write_image_line = FunctionResolver.GetFunctionDelegate<vectors.av_write_image_line_delegate>("avutil", "av_write_image_line", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_write_image_line_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_write_image_line(src, ref data, in linesize, desc, x, y, c, w);
			};
			vectors.av_write_image_line2 = delegate(void* src, ref byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int src_element_size)
			{
				vectors.av_write_image_line2 = FunctionResolver.GetFunctionDelegate<vectors.av_write_image_line2_delegate>("avutil", "av_write_image_line2", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_write_image_line2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.av_write_image_line2(src, ref data, in linesize, desc, x, y, c, w, src_element_size);
			};
			vectors.av_write_trailer = delegate(AVFormatContext* s)
			{
				vectors.av_write_trailer = FunctionResolver.GetFunctionDelegate<vectors.av_write_trailer_delegate>("avformat", "av_write_trailer", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_write_trailer_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_write_trailer(s);
			};
			vectors.av_write_uncoded_frame = delegate(AVFormatContext* s, int stream_index, AVFrame* frame)
			{
				vectors.av_write_uncoded_frame = FunctionResolver.GetFunctionDelegate<vectors.av_write_uncoded_frame_delegate>("avformat", "av_write_uncoded_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_write_uncoded_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_write_uncoded_frame(s, stream_index, frame);
			};
			vectors.av_write_uncoded_frame_query = delegate(AVFormatContext* s, int stream_index)
			{
				vectors.av_write_uncoded_frame_query = FunctionResolver.GetFunctionDelegate<vectors.av_write_uncoded_frame_query_delegate>("avformat", "av_write_uncoded_frame_query", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_write_uncoded_frame_query_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_write_uncoded_frame_query(s, stream_index);
			};
			vectors.av_xiphlacing = delegate(byte* s, uint v)
			{
				vectors.av_xiphlacing = FunctionResolver.GetFunctionDelegate<vectors.av_xiphlacing_delegate>("avcodec", "av_xiphlacing", ThrowErrorIfFunctionNotFound) ?? ((vectors.av_xiphlacing_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.av_xiphlacing(s, v);
			};
			vectors.avcodec_align_dimensions = delegate(AVCodecContext* s, int* width, int* height)
			{
				vectors.avcodec_align_dimensions = FunctionResolver.GetFunctionDelegate<vectors.avcodec_align_dimensions_delegate>("avcodec", "avcodec_align_dimensions", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_align_dimensions_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avcodec_align_dimensions(s, width, height);
			};
			vectors.avcodec_align_dimensions2 = delegate(AVCodecContext* s, int* width, int* height, ref int_array8 linesize_align)
			{
				vectors.avcodec_align_dimensions2 = FunctionResolver.GetFunctionDelegate<vectors.avcodec_align_dimensions2_delegate>("avcodec", "avcodec_align_dimensions2", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_align_dimensions2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avcodec_align_dimensions2(s, width, height, ref linesize_align);
			};
			vectors.avcodec_alloc_context3 = delegate(AVCodec* codec)
			{
				vectors.avcodec_alloc_context3 = FunctionResolver.GetFunctionDelegate<vectors.avcodec_alloc_context3_delegate>("avcodec", "avcodec_alloc_context3", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_alloc_context3_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_alloc_context3(codec);
			};
			vectors.avcodec_configuration = delegate
			{
				vectors.avcodec_configuration = FunctionResolver.GetFunctionDelegate<vectors.avcodec_configuration_delegate>("avcodec", "avcodec_configuration", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_configuration_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_configuration();
			};
			vectors.avcodec_decode_subtitle2 = delegate(AVCodecContext* avctx, AVSubtitle* sub, int* got_sub_ptr, AVPacket* avpkt)
			{
				vectors.avcodec_decode_subtitle2 = FunctionResolver.GetFunctionDelegate<vectors.avcodec_decode_subtitle2_delegate>("avcodec", "avcodec_decode_subtitle2", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_decode_subtitle2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, avpkt);
			};
			vectors.avcodec_default_execute = delegate(AVCodecContext* c, avcodec_default_execute_func_func func, void* arg, int* ret, int count, int size)
			{
				vectors.avcodec_default_execute = FunctionResolver.GetFunctionDelegate<vectors.avcodec_default_execute_delegate>("avcodec", "avcodec_default_execute", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_default_execute_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_default_execute(c, func, arg, ret, count, size);
			};
			vectors.avcodec_default_execute2 = delegate(AVCodecContext* c, avcodec_default_execute2_func_func func, void* arg, int* ret, int count)
			{
				vectors.avcodec_default_execute2 = FunctionResolver.GetFunctionDelegate<vectors.avcodec_default_execute2_delegate>("avcodec", "avcodec_default_execute2", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_default_execute2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_default_execute2(c, func, arg, ret, count);
			};
			vectors.avcodec_default_get_buffer2 = delegate(AVCodecContext* s, AVFrame* frame, int flags)
			{
				vectors.avcodec_default_get_buffer2 = FunctionResolver.GetFunctionDelegate<vectors.avcodec_default_get_buffer2_delegate>("avcodec", "avcodec_default_get_buffer2", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_default_get_buffer2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_default_get_buffer2(s, frame, flags);
			};
			vectors.avcodec_default_get_encode_buffer = delegate(AVCodecContext* s, AVPacket* pkt, int flags)
			{
				vectors.avcodec_default_get_encode_buffer = FunctionResolver.GetFunctionDelegate<vectors.avcodec_default_get_encode_buffer_delegate>("avcodec", "avcodec_default_get_encode_buffer", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_default_get_encode_buffer_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_default_get_encode_buffer(s, pkt, flags);
			};
			vectors.avcodec_default_get_format = delegate(AVCodecContext* s, AVPixelFormat* fmt)
			{
				vectors.avcodec_default_get_format = FunctionResolver.GetFunctionDelegate<vectors.avcodec_default_get_format_delegate>("avcodec", "avcodec_default_get_format", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_default_get_format_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_default_get_format(s, fmt);
			};
			vectors.avcodec_descriptor_get = delegate(AVCodecID id)
			{
				vectors.avcodec_descriptor_get = FunctionResolver.GetFunctionDelegate<vectors.avcodec_descriptor_get_delegate>("avcodec", "avcodec_descriptor_get", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_descriptor_get_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_descriptor_get(id);
			};
			vectors.avcodec_descriptor_get_by_name = delegate(string name)
			{
				vectors.avcodec_descriptor_get_by_name = FunctionResolver.GetFunctionDelegate<vectors.avcodec_descriptor_get_by_name_delegate>("avcodec", "avcodec_descriptor_get_by_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_descriptor_get_by_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_descriptor_get_by_name(name);
			};
			vectors.avcodec_descriptor_next = delegate(AVCodecDescriptor* prev)
			{
				vectors.avcodec_descriptor_next = FunctionResolver.GetFunctionDelegate<vectors.avcodec_descriptor_next_delegate>("avcodec", "avcodec_descriptor_next", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_descriptor_next_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_descriptor_next(prev);
			};
			vectors.avcodec_encode_subtitle = delegate(AVCodecContext* avctx, byte* buf, int buf_size, AVSubtitle* sub)
			{
				vectors.avcodec_encode_subtitle = FunctionResolver.GetFunctionDelegate<vectors.avcodec_encode_subtitle_delegate>("avcodec", "avcodec_encode_subtitle", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_encode_subtitle_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_encode_subtitle(avctx, buf, buf_size, sub);
			};
			vectors.avcodec_fill_audio_frame = delegate(AVFrame* frame, int nb_channels, AVSampleFormat sample_fmt, byte* buf, int buf_size, int align)
			{
				vectors.avcodec_fill_audio_frame = FunctionResolver.GetFunctionDelegate<vectors.avcodec_fill_audio_frame_delegate>("avcodec", "avcodec_fill_audio_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_fill_audio_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_fill_audio_frame(frame, nb_channels, sample_fmt, buf, buf_size, align);
			};
			vectors.avcodec_find_best_pix_fmt_of_list = delegate(AVPixelFormat* pix_fmt_list, AVPixelFormat src_pix_fmt, int has_alpha, int* loss_ptr)
			{
				vectors.avcodec_find_best_pix_fmt_of_list = FunctionResolver.GetFunctionDelegate<vectors.avcodec_find_best_pix_fmt_of_list_delegate>("avcodec", "avcodec_find_best_pix_fmt_of_list", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_find_best_pix_fmt_of_list_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_find_best_pix_fmt_of_list(pix_fmt_list, src_pix_fmt, has_alpha, loss_ptr);
			};
			vectors.avcodec_find_decoder = delegate(AVCodecID id)
			{
				vectors.avcodec_find_decoder = FunctionResolver.GetFunctionDelegate<vectors.avcodec_find_decoder_delegate>("avcodec", "avcodec_find_decoder", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_find_decoder_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_find_decoder(id);
			};
			vectors.avcodec_find_decoder_by_name = delegate(string name)
			{
				vectors.avcodec_find_decoder_by_name = FunctionResolver.GetFunctionDelegate<vectors.avcodec_find_decoder_by_name_delegate>("avcodec", "avcodec_find_decoder_by_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_find_decoder_by_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_find_decoder_by_name(name);
			};
			vectors.avcodec_find_encoder = delegate(AVCodecID id)
			{
				vectors.avcodec_find_encoder = FunctionResolver.GetFunctionDelegate<vectors.avcodec_find_encoder_delegate>("avcodec", "avcodec_find_encoder", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_find_encoder_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_find_encoder(id);
			};
			vectors.avcodec_find_encoder_by_name = delegate(string name)
			{
				vectors.avcodec_find_encoder_by_name = FunctionResolver.GetFunctionDelegate<vectors.avcodec_find_encoder_by_name_delegate>("avcodec", "avcodec_find_encoder_by_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_find_encoder_by_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_find_encoder_by_name(name);
			};
			vectors.avcodec_flush_buffers = delegate(AVCodecContext* avctx)
			{
				vectors.avcodec_flush_buffers = FunctionResolver.GetFunctionDelegate<vectors.avcodec_flush_buffers_delegate>("avcodec", "avcodec_flush_buffers", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_flush_buffers_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avcodec_flush_buffers(avctx);
			};
			vectors.avcodec_free_context = delegate(AVCodecContext** avctx)
			{
				vectors.avcodec_free_context = FunctionResolver.GetFunctionDelegate<vectors.avcodec_free_context_delegate>("avcodec", "avcodec_free_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_free_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avcodec_free_context(avctx);
			};
			vectors.avcodec_get_class = delegate
			{
				vectors.avcodec_get_class = FunctionResolver.GetFunctionDelegate<vectors.avcodec_get_class_delegate>("avcodec", "avcodec_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_get_class();
			};
			vectors.avcodec_get_hw_config = delegate(AVCodec* codec, int index)
			{
				vectors.avcodec_get_hw_config = FunctionResolver.GetFunctionDelegate<vectors.avcodec_get_hw_config_delegate>("avcodec", "avcodec_get_hw_config", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_get_hw_config_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_get_hw_config(codec, index);
			};
			vectors.avcodec_get_hw_frames_parameters = delegate(AVCodecContext* avctx, AVBufferRef* device_ref, AVPixelFormat hw_pix_fmt, AVBufferRef** out_frames_ref)
			{
				vectors.avcodec_get_hw_frames_parameters = FunctionResolver.GetFunctionDelegate<vectors.avcodec_get_hw_frames_parameters_delegate>("avcodec", "avcodec_get_hw_frames_parameters", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_get_hw_frames_parameters_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_get_hw_frames_parameters(avctx, device_ref, hw_pix_fmt, out_frames_ref);
			};
			vectors.avcodec_get_name = delegate(AVCodecID id)
			{
				vectors.avcodec_get_name = FunctionResolver.GetFunctionDelegate<vectors.avcodec_get_name_delegate>("avcodec", "avcodec_get_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_get_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_get_name(id);
			};
			vectors.avcodec_get_subtitle_rect_class = delegate
			{
				vectors.avcodec_get_subtitle_rect_class = FunctionResolver.GetFunctionDelegate<vectors.avcodec_get_subtitle_rect_class_delegate>("avcodec", "avcodec_get_subtitle_rect_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_get_subtitle_rect_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_get_subtitle_rect_class();
			};
			vectors.avcodec_get_supported_config = delegate(AVCodecContext* avctx, AVCodec* codec, AVCodecConfig config, uint flags, void** out_configs, int* out_num_configs)
			{
				vectors.avcodec_get_supported_config = FunctionResolver.GetFunctionDelegate<vectors.avcodec_get_supported_config_delegate>("avcodec", "avcodec_get_supported_config", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_get_supported_config_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_get_supported_config(avctx, codec, config, flags, out_configs, out_num_configs);
			};
			vectors.avcodec_get_type = delegate(AVCodecID codec_id)
			{
				vectors.avcodec_get_type = FunctionResolver.GetFunctionDelegate<vectors.avcodec_get_type_delegate>("avcodec", "avcodec_get_type", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_get_type_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_get_type(codec_id);
			};
			vectors.avcodec_is_open = delegate(AVCodecContext* s)
			{
				vectors.avcodec_is_open = FunctionResolver.GetFunctionDelegate<vectors.avcodec_is_open_delegate>("avcodec", "avcodec_is_open", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_is_open_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_is_open(s);
			};
			vectors.avcodec_license = delegate
			{
				vectors.avcodec_license = FunctionResolver.GetFunctionDelegate<vectors.avcodec_license_delegate>("avcodec", "avcodec_license", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_license_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_license();
			};
			vectors.avcodec_open2 = delegate(AVCodecContext* avctx, AVCodec* codec, AVDictionary** options)
			{
				vectors.avcodec_open2 = FunctionResolver.GetFunctionDelegate<vectors.avcodec_open2_delegate>("avcodec", "avcodec_open2", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_open2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_open2(avctx, codec, options);
			};
			vectors.avcodec_parameters_alloc = delegate
			{
				vectors.avcodec_parameters_alloc = FunctionResolver.GetFunctionDelegate<vectors.avcodec_parameters_alloc_delegate>("avcodec", "avcodec_parameters_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_parameters_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_parameters_alloc();
			};
			vectors.avcodec_parameters_copy = delegate(AVCodecParameters* dst, AVCodecParameters* src)
			{
				vectors.avcodec_parameters_copy = FunctionResolver.GetFunctionDelegate<vectors.avcodec_parameters_copy_delegate>("avcodec", "avcodec_parameters_copy", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_parameters_copy_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_parameters_copy(dst, src);
			};
			vectors.avcodec_parameters_free = delegate(AVCodecParameters** par)
			{
				vectors.avcodec_parameters_free = FunctionResolver.GetFunctionDelegate<vectors.avcodec_parameters_free_delegate>("avcodec", "avcodec_parameters_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_parameters_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avcodec_parameters_free(par);
			};
			vectors.avcodec_parameters_from_context = delegate(AVCodecParameters* par, AVCodecContext* codec)
			{
				vectors.avcodec_parameters_from_context = FunctionResolver.GetFunctionDelegate<vectors.avcodec_parameters_from_context_delegate>("avcodec", "avcodec_parameters_from_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_parameters_from_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_parameters_from_context(par, codec);
			};
			vectors.avcodec_parameters_to_context = delegate(AVCodecContext* codec, AVCodecParameters* par)
			{
				vectors.avcodec_parameters_to_context = FunctionResolver.GetFunctionDelegate<vectors.avcodec_parameters_to_context_delegate>("avcodec", "avcodec_parameters_to_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_parameters_to_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_parameters_to_context(codec, par);
			};
			vectors.avcodec_pix_fmt_to_codec_tag = delegate(AVPixelFormat pix_fmt)
			{
				vectors.avcodec_pix_fmt_to_codec_tag = FunctionResolver.GetFunctionDelegate<vectors.avcodec_pix_fmt_to_codec_tag_delegate>("avcodec", "avcodec_pix_fmt_to_codec_tag", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_pix_fmt_to_codec_tag_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_pix_fmt_to_codec_tag(pix_fmt);
			};
			vectors.avcodec_profile_name = delegate(AVCodecID codec_id, int profile)
			{
				vectors.avcodec_profile_name = FunctionResolver.GetFunctionDelegate<vectors.avcodec_profile_name_delegate>("avcodec", "avcodec_profile_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_profile_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_profile_name(codec_id, profile);
			};
			vectors.avcodec_receive_frame = delegate(AVCodecContext* avctx, AVFrame* frame)
			{
				vectors.avcodec_receive_frame = FunctionResolver.GetFunctionDelegate<vectors.avcodec_receive_frame_delegate>("avcodec", "avcodec_receive_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_receive_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_receive_frame(avctx, frame);
			};
			vectors.avcodec_receive_packet = delegate(AVCodecContext* avctx, AVPacket* avpkt)
			{
				vectors.avcodec_receive_packet = FunctionResolver.GetFunctionDelegate<vectors.avcodec_receive_packet_delegate>("avcodec", "avcodec_receive_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_receive_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_receive_packet(avctx, avpkt);
			};
			vectors.avcodec_send_frame = delegate(AVCodecContext* avctx, AVFrame* frame)
			{
				vectors.avcodec_send_frame = FunctionResolver.GetFunctionDelegate<vectors.avcodec_send_frame_delegate>("avcodec", "avcodec_send_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_send_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_send_frame(avctx, frame);
			};
			vectors.avcodec_send_packet = delegate(AVCodecContext* avctx, AVPacket* avpkt)
			{
				vectors.avcodec_send_packet = FunctionResolver.GetFunctionDelegate<vectors.avcodec_send_packet_delegate>("avcodec", "avcodec_send_packet", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_send_packet_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_send_packet(avctx, avpkt);
			};
			vectors.avcodec_string = delegate(byte* buf, int buf_size, AVCodecContext* enc, int encode)
			{
				vectors.avcodec_string = FunctionResolver.GetFunctionDelegate<vectors.avcodec_string_delegate>("avcodec", "avcodec_string", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_string_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avcodec_string(buf, buf_size, enc, encode);
			};
			vectors.avcodec_version = delegate
			{
				vectors.avcodec_version = FunctionResolver.GetFunctionDelegate<vectors.avcodec_version_delegate>("avcodec", "avcodec_version", ThrowErrorIfFunctionNotFound) ?? ((vectors.avcodec_version_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avcodec_version();
			};
			vectors.avdevice_app_to_dev_control_message = delegate(AVFormatContext* s, AVAppToDevMessageType type, void* data, ulong data_size)
			{
				vectors.avdevice_app_to_dev_control_message = FunctionResolver.GetFunctionDelegate<vectors.avdevice_app_to_dev_control_message_delegate>("avdevice", "avdevice_app_to_dev_control_message", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_app_to_dev_control_message_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avdevice_app_to_dev_control_message(s, type, data, data_size);
			};
			vectors.avdevice_configuration = delegate
			{
				vectors.avdevice_configuration = FunctionResolver.GetFunctionDelegate<vectors.avdevice_configuration_delegate>("avdevice", "avdevice_configuration", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_configuration_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avdevice_configuration();
			};
			vectors.avdevice_dev_to_app_control_message = delegate(AVFormatContext* s, AVDevToAppMessageType type, void* data, ulong data_size)
			{
				vectors.avdevice_dev_to_app_control_message = FunctionResolver.GetFunctionDelegate<vectors.avdevice_dev_to_app_control_message_delegate>("avdevice", "avdevice_dev_to_app_control_message", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_dev_to_app_control_message_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avdevice_dev_to_app_control_message(s, type, data, data_size);
			};
			vectors.avdevice_free_list_devices = delegate(AVDeviceInfoList** device_list)
			{
				vectors.avdevice_free_list_devices = FunctionResolver.GetFunctionDelegate<vectors.avdevice_free_list_devices_delegate>("avdevice", "avdevice_free_list_devices", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_free_list_devices_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avdevice_free_list_devices(device_list);
			};
			vectors.avdevice_license = delegate
			{
				vectors.avdevice_license = FunctionResolver.GetFunctionDelegate<vectors.avdevice_license_delegate>("avdevice", "avdevice_license", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_license_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avdevice_license();
			};
			vectors.avdevice_list_devices = delegate(AVFormatContext* s, AVDeviceInfoList** device_list)
			{
				vectors.avdevice_list_devices = FunctionResolver.GetFunctionDelegate<vectors.avdevice_list_devices_delegate>("avdevice", "avdevice_list_devices", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_list_devices_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avdevice_list_devices(s, device_list);
			};
			vectors.avdevice_list_input_sources = delegate(AVInputFormat* device, string device_name, AVDictionary* device_options, AVDeviceInfoList** device_list)
			{
				vectors.avdevice_list_input_sources = FunctionResolver.GetFunctionDelegate<vectors.avdevice_list_input_sources_delegate>("avdevice", "avdevice_list_input_sources", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_list_input_sources_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avdevice_list_input_sources(device, device_name, device_options, device_list);
			};
			vectors.avdevice_list_output_sinks = delegate(AVOutputFormat* device, string device_name, AVDictionary* device_options, AVDeviceInfoList** device_list)
			{
				vectors.avdevice_list_output_sinks = FunctionResolver.GetFunctionDelegate<vectors.avdevice_list_output_sinks_delegate>("avdevice", "avdevice_list_output_sinks", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_list_output_sinks_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avdevice_list_output_sinks(device, device_name, device_options, device_list);
			};
			vectors.avdevice_register_all = delegate
			{
				vectors.avdevice_register_all = FunctionResolver.GetFunctionDelegate<vectors.avdevice_register_all_delegate>("avdevice", "avdevice_register_all", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_register_all_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avdevice_register_all();
			};
			vectors.avdevice_version = delegate
			{
				vectors.avdevice_version = FunctionResolver.GetFunctionDelegate<vectors.avdevice_version_delegate>("avdevice", "avdevice_version", ThrowErrorIfFunctionNotFound) ?? ((vectors.avdevice_version_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avdevice_version();
			};
			vectors.avfilter_configuration = delegate
			{
				vectors.avfilter_configuration = FunctionResolver.GetFunctionDelegate<vectors.avfilter_configuration_delegate>("avfilter", "avfilter_configuration", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_configuration_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_configuration();
			};
			vectors.avfilter_filter_pad_count = delegate(AVFilter* filter, int is_output)
			{
				vectors.avfilter_filter_pad_count = FunctionResolver.GetFunctionDelegate<vectors.avfilter_filter_pad_count_delegate>("avfilter", "avfilter_filter_pad_count", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_filter_pad_count_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_filter_pad_count(filter, is_output);
			};
			vectors.avfilter_free = delegate(AVFilterContext* filter)
			{
				vectors.avfilter_free = FunctionResolver.GetFunctionDelegate<vectors.avfilter_free_delegate>("avfilter", "avfilter_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avfilter_free(filter);
			};
			vectors.avfilter_get_by_name = delegate(string name)
			{
				vectors.avfilter_get_by_name = FunctionResolver.GetFunctionDelegate<vectors.avfilter_get_by_name_delegate>("avfilter", "avfilter_get_by_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_get_by_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_get_by_name(name);
			};
			vectors.avfilter_get_class = delegate
			{
				vectors.avfilter_get_class = FunctionResolver.GetFunctionDelegate<vectors.avfilter_get_class_delegate>("avfilter", "avfilter_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_get_class();
			};
			vectors.avfilter_graph_alloc = delegate
			{
				vectors.avfilter_graph_alloc = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_alloc_delegate>("avfilter", "avfilter_graph_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_alloc();
			};
			vectors.avfilter_graph_alloc_filter = delegate(AVFilterGraph* graph, AVFilter* filter, string name)
			{
				vectors.avfilter_graph_alloc_filter = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_alloc_filter_delegate>("avfilter", "avfilter_graph_alloc_filter", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_alloc_filter_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_alloc_filter(graph, filter, name);
			};
			vectors.avfilter_graph_config = delegate(AVFilterGraph* graphctx, void* log_ctx)
			{
				vectors.avfilter_graph_config = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_config_delegate>("avfilter", "avfilter_graph_config", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_config_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_config(graphctx, log_ctx);
			};
			vectors.avfilter_graph_create_filter = delegate(AVFilterContext** filt_ctx, AVFilter* filt, string name, string args, void* opaque, AVFilterGraph* graph_ctx)
			{
				vectors.avfilter_graph_create_filter = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_create_filter_delegate>("avfilter", "avfilter_graph_create_filter", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_create_filter_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_create_filter(filt_ctx, filt, name, args, opaque, graph_ctx);
			};
			vectors.avfilter_graph_dump = delegate(AVFilterGraph* graph, string options)
			{
				vectors.avfilter_graph_dump = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_dump_delegate>("avfilter", "avfilter_graph_dump", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_dump_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_dump(graph, options);
			};
			vectors.avfilter_graph_free = delegate(AVFilterGraph** graph)
			{
				vectors.avfilter_graph_free = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_free_delegate>("avfilter", "avfilter_graph_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avfilter_graph_free(graph);
			};
			vectors.avfilter_graph_get_filter = delegate(AVFilterGraph* graph, string name)
			{
				vectors.avfilter_graph_get_filter = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_get_filter_delegate>("avfilter", "avfilter_graph_get_filter", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_get_filter_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_get_filter(graph, name);
			};
			vectors.avfilter_graph_parse = delegate(AVFilterGraph* graph, string filters, AVFilterInOut* inputs, AVFilterInOut* outputs, void* log_ctx)
			{
				vectors.avfilter_graph_parse = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_parse_delegate>("avfilter", "avfilter_graph_parse", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_parse_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_parse(graph, filters, inputs, outputs, log_ctx);
			};
			vectors.avfilter_graph_parse_ptr = delegate(AVFilterGraph* graph, string filters, AVFilterInOut** inputs, AVFilterInOut** outputs, void* log_ctx)
			{
				vectors.avfilter_graph_parse_ptr = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_parse_ptr_delegate>("avfilter", "avfilter_graph_parse_ptr", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_parse_ptr_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_parse_ptr(graph, filters, inputs, outputs, log_ctx);
			};
			vectors.avfilter_graph_parse2 = delegate(AVFilterGraph* graph, string filters, AVFilterInOut** inputs, AVFilterInOut** outputs)
			{
				vectors.avfilter_graph_parse2 = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_parse2_delegate>("avfilter", "avfilter_graph_parse2", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_parse2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_parse2(graph, filters, inputs, outputs);
			};
			vectors.avfilter_graph_queue_command = delegate(AVFilterGraph* graph, string target, string cmd, string arg, int flags, double ts)
			{
				vectors.avfilter_graph_queue_command = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_queue_command_delegate>("avfilter", "avfilter_graph_queue_command", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_queue_command_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_queue_command(graph, target, cmd, arg, flags, ts);
			};
			vectors.avfilter_graph_request_oldest = delegate(AVFilterGraph* graph)
			{
				vectors.avfilter_graph_request_oldest = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_request_oldest_delegate>("avfilter", "avfilter_graph_request_oldest", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_request_oldest_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_request_oldest(graph);
			};
			vectors.avfilter_graph_segment_apply = delegate(AVFilterGraphSegment* seg, int flags, AVFilterInOut** inputs, AVFilterInOut** outputs)
			{
				vectors.avfilter_graph_segment_apply = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_segment_apply_delegate>("avfilter", "avfilter_graph_segment_apply", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_segment_apply_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_segment_apply(seg, flags, inputs, outputs);
			};
			vectors.avfilter_graph_segment_apply_opts = delegate(AVFilterGraphSegment* seg, int flags)
			{
				vectors.avfilter_graph_segment_apply_opts = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_segment_apply_opts_delegate>("avfilter", "avfilter_graph_segment_apply_opts", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_segment_apply_opts_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_segment_apply_opts(seg, flags);
			};
			vectors.avfilter_graph_segment_create_filters = delegate(AVFilterGraphSegment* seg, int flags)
			{
				vectors.avfilter_graph_segment_create_filters = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_segment_create_filters_delegate>("avfilter", "avfilter_graph_segment_create_filters", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_segment_create_filters_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_segment_create_filters(seg, flags);
			};
			vectors.avfilter_graph_segment_free = delegate(AVFilterGraphSegment** seg)
			{
				vectors.avfilter_graph_segment_free = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_segment_free_delegate>("avfilter", "avfilter_graph_segment_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_segment_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avfilter_graph_segment_free(seg);
			};
			vectors.avfilter_graph_segment_init = delegate(AVFilterGraphSegment* seg, int flags)
			{
				vectors.avfilter_graph_segment_init = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_segment_init_delegate>("avfilter", "avfilter_graph_segment_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_segment_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_segment_init(seg, flags);
			};
			vectors.avfilter_graph_segment_link = delegate(AVFilterGraphSegment* seg, int flags, AVFilterInOut** inputs, AVFilterInOut** outputs)
			{
				vectors.avfilter_graph_segment_link = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_segment_link_delegate>("avfilter", "avfilter_graph_segment_link", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_segment_link_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_segment_link(seg, flags, inputs, outputs);
			};
			vectors.avfilter_graph_segment_parse = delegate(AVFilterGraph* graph, string graph_str, int flags, AVFilterGraphSegment** seg)
			{
				vectors.avfilter_graph_segment_parse = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_segment_parse_delegate>("avfilter", "avfilter_graph_segment_parse", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_segment_parse_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_segment_parse(graph, graph_str, flags, seg);
			};
			vectors.avfilter_graph_send_command = delegate(AVFilterGraph* graph, string target, string cmd, string arg, byte* res, int res_len, int flags)
			{
				vectors.avfilter_graph_send_command = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_send_command_delegate>("avfilter", "avfilter_graph_send_command", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_send_command_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags);
			};
			vectors.avfilter_graph_set_auto_convert = delegate(AVFilterGraph* graph, uint flags)
			{
				vectors.avfilter_graph_set_auto_convert = FunctionResolver.GetFunctionDelegate<vectors.avfilter_graph_set_auto_convert_delegate>("avfilter", "avfilter_graph_set_auto_convert", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_graph_set_auto_convert_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avfilter_graph_set_auto_convert(graph, flags);
			};
			vectors.avfilter_init_dict = delegate(AVFilterContext* ctx, AVDictionary** options)
			{
				vectors.avfilter_init_dict = FunctionResolver.GetFunctionDelegate<vectors.avfilter_init_dict_delegate>("avfilter", "avfilter_init_dict", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_init_dict_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_init_dict(ctx, options);
			};
			vectors.avfilter_init_str = delegate(AVFilterContext* ctx, string args)
			{
				vectors.avfilter_init_str = FunctionResolver.GetFunctionDelegate<vectors.avfilter_init_str_delegate>("avfilter", "avfilter_init_str", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_init_str_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_init_str(ctx, args);
			};
			vectors.avfilter_inout_alloc = delegate
			{
				vectors.avfilter_inout_alloc = FunctionResolver.GetFunctionDelegate<vectors.avfilter_inout_alloc_delegate>("avfilter", "avfilter_inout_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_inout_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_inout_alloc();
			};
			vectors.avfilter_inout_free = delegate(AVFilterInOut** inout)
			{
				vectors.avfilter_inout_free = FunctionResolver.GetFunctionDelegate<vectors.avfilter_inout_free_delegate>("avfilter", "avfilter_inout_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_inout_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avfilter_inout_free(inout);
			};
			vectors.avfilter_insert_filter = delegate(AVFilterLink* link, AVFilterContext* filt, uint filt_srcpad_idx, uint filt_dstpad_idx)
			{
				vectors.avfilter_insert_filter = FunctionResolver.GetFunctionDelegate<vectors.avfilter_insert_filter_delegate>("avfilter", "avfilter_insert_filter", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_insert_filter_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_insert_filter(link, filt, filt_srcpad_idx, filt_dstpad_idx);
			};
			vectors.avfilter_license = delegate
			{
				vectors.avfilter_license = FunctionResolver.GetFunctionDelegate<vectors.avfilter_license_delegate>("avfilter", "avfilter_license", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_license_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_license();
			};
			vectors.avfilter_link = delegate(AVFilterContext* src, uint srcpad, AVFilterContext* dst, uint dstpad)
			{
				vectors.avfilter_link = FunctionResolver.GetFunctionDelegate<vectors.avfilter_link_delegate>("avfilter", "avfilter_link", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_link_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_link(src, srcpad, dst, dstpad);
			};
			vectors.avfilter_link_get_hw_frames_ctx = delegate(AVFilterLink* link)
			{
				vectors.avfilter_link_get_hw_frames_ctx = FunctionResolver.GetFunctionDelegate<vectors.avfilter_link_get_hw_frames_ctx_delegate>("avfilter", "avfilter_link_get_hw_frames_ctx", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_link_get_hw_frames_ctx_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_link_get_hw_frames_ctx(link);
			};
			vectors.avfilter_pad_get_name = delegate(AVFilterPad* pads, int pad_idx)
			{
				vectors.avfilter_pad_get_name = FunctionResolver.GetFunctionDelegate<vectors.avfilter_pad_get_name_delegate>("avfilter", "avfilter_pad_get_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_pad_get_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_pad_get_name(pads, pad_idx);
			};
			vectors.avfilter_pad_get_type = delegate(AVFilterPad* pads, int pad_idx)
			{
				vectors.avfilter_pad_get_type = FunctionResolver.GetFunctionDelegate<vectors.avfilter_pad_get_type_delegate>("avfilter", "avfilter_pad_get_type", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_pad_get_type_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_pad_get_type(pads, pad_idx);
			};
			vectors.avfilter_process_command = delegate(AVFilterContext* filter, string cmd, string arg, byte* res, int res_len, int flags)
			{
				vectors.avfilter_process_command = FunctionResolver.GetFunctionDelegate<vectors.avfilter_process_command_delegate>("avfilter", "avfilter_process_command", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_process_command_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_process_command(filter, cmd, arg, res, res_len, flags);
			};
			vectors.avfilter_version = delegate
			{
				vectors.avfilter_version = FunctionResolver.GetFunctionDelegate<vectors.avfilter_version_delegate>("avfilter", "avfilter_version", ThrowErrorIfFunctionNotFound) ?? ((vectors.avfilter_version_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avfilter_version();
			};
			vectors.avformat_alloc_context = delegate
			{
				vectors.avformat_alloc_context = FunctionResolver.GetFunctionDelegate<vectors.avformat_alloc_context_delegate>("avformat", "avformat_alloc_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_alloc_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_alloc_context();
			};
			vectors.avformat_alloc_output_context2 = delegate(AVFormatContext** ctx, AVOutputFormat* oformat, string format_name, string filename)
			{
				vectors.avformat_alloc_output_context2 = FunctionResolver.GetFunctionDelegate<vectors.avformat_alloc_output_context2_delegate>("avformat", "avformat_alloc_output_context2", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_alloc_output_context2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_alloc_output_context2(ctx, oformat, format_name, filename);
			};
			vectors.avformat_close_input = delegate(AVFormatContext** s)
			{
				vectors.avformat_close_input = FunctionResolver.GetFunctionDelegate<vectors.avformat_close_input_delegate>("avformat", "avformat_close_input", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_close_input_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avformat_close_input(s);
			};
			vectors.avformat_configuration = delegate
			{
				vectors.avformat_configuration = FunctionResolver.GetFunctionDelegate<vectors.avformat_configuration_delegate>("avformat", "avformat_configuration", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_configuration_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_configuration();
			};
			vectors.avformat_find_stream_info = delegate(AVFormatContext* ic, AVDictionary** options)
			{
				vectors.avformat_find_stream_info = FunctionResolver.GetFunctionDelegate<vectors.avformat_find_stream_info_delegate>("avformat", "avformat_find_stream_info", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_find_stream_info_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_find_stream_info(ic, options);
			};
			vectors.avformat_flush = delegate(AVFormatContext* s)
			{
				vectors.avformat_flush = FunctionResolver.GetFunctionDelegate<vectors.avformat_flush_delegate>("avformat", "avformat_flush", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_flush_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_flush(s);
			};
			vectors.avformat_free_context = delegate(AVFormatContext* s)
			{
				vectors.avformat_free_context = FunctionResolver.GetFunctionDelegate<vectors.avformat_free_context_delegate>("avformat", "avformat_free_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_free_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avformat_free_context(s);
			};
			vectors.avformat_get_class = delegate
			{
				vectors.avformat_get_class = FunctionResolver.GetFunctionDelegate<vectors.avformat_get_class_delegate>("avformat", "avformat_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_get_class();
			};
			vectors.avformat_get_mov_audio_tags = delegate
			{
				vectors.avformat_get_mov_audio_tags = FunctionResolver.GetFunctionDelegate<vectors.avformat_get_mov_audio_tags_delegate>("avformat", "avformat_get_mov_audio_tags", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_get_mov_audio_tags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_get_mov_audio_tags();
			};
			vectors.avformat_get_mov_video_tags = delegate
			{
				vectors.avformat_get_mov_video_tags = FunctionResolver.GetFunctionDelegate<vectors.avformat_get_mov_video_tags_delegate>("avformat", "avformat_get_mov_video_tags", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_get_mov_video_tags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_get_mov_video_tags();
			};
			vectors.avformat_get_riff_audio_tags = delegate
			{
				vectors.avformat_get_riff_audio_tags = FunctionResolver.GetFunctionDelegate<vectors.avformat_get_riff_audio_tags_delegate>("avformat", "avformat_get_riff_audio_tags", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_get_riff_audio_tags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_get_riff_audio_tags();
			};
			vectors.avformat_get_riff_video_tags = delegate
			{
				vectors.avformat_get_riff_video_tags = FunctionResolver.GetFunctionDelegate<vectors.avformat_get_riff_video_tags_delegate>("avformat", "avformat_get_riff_video_tags", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_get_riff_video_tags_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_get_riff_video_tags();
			};
			vectors.avformat_index_get_entries_count = delegate(AVStream* st)
			{
				vectors.avformat_index_get_entries_count = FunctionResolver.GetFunctionDelegate<vectors.avformat_index_get_entries_count_delegate>("avformat", "avformat_index_get_entries_count", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_index_get_entries_count_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_index_get_entries_count(st);
			};
			vectors.avformat_index_get_entry = delegate(AVStream* st, int idx)
			{
				vectors.avformat_index_get_entry = FunctionResolver.GetFunctionDelegate<vectors.avformat_index_get_entry_delegate>("avformat", "avformat_index_get_entry", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_index_get_entry_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_index_get_entry(st, idx);
			};
			vectors.avformat_index_get_entry_from_timestamp = delegate(AVStream* st, long wanted_timestamp, int flags)
			{
				vectors.avformat_index_get_entry_from_timestamp = FunctionResolver.GetFunctionDelegate<vectors.avformat_index_get_entry_from_timestamp_delegate>("avformat", "avformat_index_get_entry_from_timestamp", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_index_get_entry_from_timestamp_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_index_get_entry_from_timestamp(st, wanted_timestamp, flags);
			};
			vectors.avformat_init_output = delegate(AVFormatContext* s, AVDictionary** options)
			{
				vectors.avformat_init_output = FunctionResolver.GetFunctionDelegate<vectors.avformat_init_output_delegate>("avformat", "avformat_init_output", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_init_output_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_init_output(s, options);
			};
			vectors.avformat_license = delegate
			{
				vectors.avformat_license = FunctionResolver.GetFunctionDelegate<vectors.avformat_license_delegate>("avformat", "avformat_license", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_license_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_license();
			};
			vectors.avformat_match_stream_specifier = delegate(AVFormatContext* s, AVStream* st, string spec)
			{
				vectors.avformat_match_stream_specifier = FunctionResolver.GetFunctionDelegate<vectors.avformat_match_stream_specifier_delegate>("avformat", "avformat_match_stream_specifier", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_match_stream_specifier_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_match_stream_specifier(s, st, spec);
			};
			vectors.avformat_network_deinit = delegate
			{
				vectors.avformat_network_deinit = FunctionResolver.GetFunctionDelegate<vectors.avformat_network_deinit_delegate>("avformat", "avformat_network_deinit", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_network_deinit_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_network_deinit();
			};
			vectors.avformat_network_init = delegate
			{
				vectors.avformat_network_init = FunctionResolver.GetFunctionDelegate<vectors.avformat_network_init_delegate>("avformat", "avformat_network_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_network_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_network_init();
			};
			vectors.avformat_new_stream = delegate(AVFormatContext* s, AVCodec* c)
			{
				vectors.avformat_new_stream = FunctionResolver.GetFunctionDelegate<vectors.avformat_new_stream_delegate>("avformat", "avformat_new_stream", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_new_stream_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_new_stream(s, c);
			};
			vectors.avformat_open_input = delegate(AVFormatContext** ps, string url, AVInputFormat* fmt, AVDictionary** options)
			{
				vectors.avformat_open_input = FunctionResolver.GetFunctionDelegate<vectors.avformat_open_input_delegate>("avformat", "avformat_open_input", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_open_input_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_open_input(ps, url, fmt, options);
			};
			vectors.avformat_query_codec = delegate(AVOutputFormat* ofmt, AVCodecID codec_id, int std_compliance)
			{
				vectors.avformat_query_codec = FunctionResolver.GetFunctionDelegate<vectors.avformat_query_codec_delegate>("avformat", "avformat_query_codec", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_query_codec_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_query_codec(ofmt, codec_id, std_compliance);
			};
			vectors.avformat_queue_attached_pictures = delegate(AVFormatContext* s)
			{
				vectors.avformat_queue_attached_pictures = FunctionResolver.GetFunctionDelegate<vectors.avformat_queue_attached_pictures_delegate>("avformat", "avformat_queue_attached_pictures", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_queue_attached_pictures_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_queue_attached_pictures(s);
			};
			vectors.avformat_seek_file = delegate(AVFormatContext* s, int stream_index, long min_ts, long ts, long max_ts, int flags)
			{
				vectors.avformat_seek_file = FunctionResolver.GetFunctionDelegate<vectors.avformat_seek_file_delegate>("avformat", "avformat_seek_file", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_seek_file_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_seek_file(s, stream_index, min_ts, ts, max_ts, flags);
			};
			vectors.avformat_stream_group_add_stream = delegate(AVStreamGroup* stg, AVStream* st)
			{
				vectors.avformat_stream_group_add_stream = FunctionResolver.GetFunctionDelegate<vectors.avformat_stream_group_add_stream_delegate>("avformat", "avformat_stream_group_add_stream", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_stream_group_add_stream_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_stream_group_add_stream(stg, st);
			};
			vectors.avformat_stream_group_create = delegate(AVFormatContext* s, AVStreamGroupParamsType type, AVDictionary** options)
			{
				vectors.avformat_stream_group_create = FunctionResolver.GetFunctionDelegate<vectors.avformat_stream_group_create_delegate>("avformat", "avformat_stream_group_create", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_stream_group_create_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_stream_group_create(s, type, options);
			};
			vectors.avformat_stream_group_name = delegate(AVStreamGroupParamsType type)
			{
				vectors.avformat_stream_group_name = FunctionResolver.GetFunctionDelegate<vectors.avformat_stream_group_name_delegate>("avformat", "avformat_stream_group_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_stream_group_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_stream_group_name(type);
			};
			vectors.avformat_transfer_internal_stream_timing_info = delegate(AVOutputFormat* ofmt, AVStream* ost, AVStream* ist, AVTimebaseSource copy_tb)
			{
				vectors.avformat_transfer_internal_stream_timing_info = FunctionResolver.GetFunctionDelegate<vectors.avformat_transfer_internal_stream_timing_info_delegate>("avformat", "avformat_transfer_internal_stream_timing_info", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_transfer_internal_stream_timing_info_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_transfer_internal_stream_timing_info(ofmt, ost, ist, copy_tb);
			};
			vectors.avformat_version = delegate
			{
				vectors.avformat_version = FunctionResolver.GetFunctionDelegate<vectors.avformat_version_delegate>("avformat", "avformat_version", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_version_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_version();
			};
			vectors.avformat_write_header = delegate(AVFormatContext* s, AVDictionary** options)
			{
				vectors.avformat_write_header = FunctionResolver.GetFunctionDelegate<vectors.avformat_write_header_delegate>("avformat", "avformat_write_header", ThrowErrorIfFunctionNotFound) ?? ((vectors.avformat_write_header_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avformat_write_header(s, options);
			};
			vectors.avio_accept = delegate(AVIOContext* s, AVIOContext** c)
			{
				vectors.avio_accept = FunctionResolver.GetFunctionDelegate<vectors.avio_accept_delegate>("avformat", "avio_accept", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_accept_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_accept(s, c);
			};
			vectors.avio_alloc_context = delegate(byte* buffer, int buffer_size, int write_flag, void* opaque, avio_alloc_context_read_packet_func read_packet, avio_alloc_context_write_packet_func write_packet, avio_alloc_context_seek_func seek)
			{
				vectors.avio_alloc_context = FunctionResolver.GetFunctionDelegate<vectors.avio_alloc_context_delegate>("avformat", "avio_alloc_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_alloc_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_alloc_context(buffer, buffer_size, write_flag, opaque, read_packet, write_packet, seek);
			};
			vectors.avio_check = delegate(string url, int flags)
			{
				vectors.avio_check = FunctionResolver.GetFunctionDelegate<vectors.avio_check_delegate>("avformat", "avio_check", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_check_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_check(url, flags);
			};
			vectors.avio_close = delegate(AVIOContext* s)
			{
				vectors.avio_close = FunctionResolver.GetFunctionDelegate<vectors.avio_close_delegate>("avformat", "avio_close", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_close_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_close(s);
			};
			vectors.avio_close_dir = delegate(AVIODirContext** s)
			{
				vectors.avio_close_dir = FunctionResolver.GetFunctionDelegate<vectors.avio_close_dir_delegate>("avformat", "avio_close_dir", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_close_dir_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_close_dir(s);
			};
			vectors.avio_close_dyn_buf = delegate(AVIOContext* s, byte** pbuffer)
			{
				vectors.avio_close_dyn_buf = FunctionResolver.GetFunctionDelegate<vectors.avio_close_dyn_buf_delegate>("avformat", "avio_close_dyn_buf", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_close_dyn_buf_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_close_dyn_buf(s, pbuffer);
			};
			vectors.avio_closep = delegate(AVIOContext** s)
			{
				vectors.avio_closep = FunctionResolver.GetFunctionDelegate<vectors.avio_closep_delegate>("avformat", "avio_closep", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_closep_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_closep(s);
			};
			vectors.avio_context_free = delegate(AVIOContext** s)
			{
				vectors.avio_context_free = FunctionResolver.GetFunctionDelegate<vectors.avio_context_free_delegate>("avformat", "avio_context_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_context_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_context_free(s);
			};
			vectors.avio_enum_protocols = delegate(void** opaque, int output)
			{
				vectors.avio_enum_protocols = FunctionResolver.GetFunctionDelegate<vectors.avio_enum_protocols_delegate>("avformat", "avio_enum_protocols", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_enum_protocols_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_enum_protocols(opaque, output);
			};
			vectors.avio_feof = delegate(AVIOContext* s)
			{
				vectors.avio_feof = FunctionResolver.GetFunctionDelegate<vectors.avio_feof_delegate>("avformat", "avio_feof", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_feof_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_feof(s);
			};
			vectors.avio_find_protocol_name = delegate(string url)
			{
				vectors.avio_find_protocol_name = FunctionResolver.GetFunctionDelegate<vectors.avio_find_protocol_name_delegate>("avformat", "avio_find_protocol_name", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_find_protocol_name_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_find_protocol_name(url);
			};
			vectors.avio_flush = delegate(AVIOContext* s)
			{
				vectors.avio_flush = FunctionResolver.GetFunctionDelegate<vectors.avio_flush_delegate>("avformat", "avio_flush", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_flush_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_flush(s);
			};
			vectors.avio_free_directory_entry = delegate(AVIODirEntry** entry)
			{
				vectors.avio_free_directory_entry = FunctionResolver.GetFunctionDelegate<vectors.avio_free_directory_entry_delegate>("avformat", "avio_free_directory_entry", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_free_directory_entry_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_free_directory_entry(entry);
			};
			vectors.avio_get_dyn_buf = delegate(AVIOContext* s, byte** pbuffer)
			{
				vectors.avio_get_dyn_buf = FunctionResolver.GetFunctionDelegate<vectors.avio_get_dyn_buf_delegate>("avformat", "avio_get_dyn_buf", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_get_dyn_buf_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_get_dyn_buf(s, pbuffer);
			};
			vectors.avio_get_str = delegate(AVIOContext* pb, int maxlen, byte* buf, int buflen)
			{
				vectors.avio_get_str = FunctionResolver.GetFunctionDelegate<vectors.avio_get_str_delegate>("avformat", "avio_get_str", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_get_str_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_get_str(pb, maxlen, buf, buflen);
			};
			vectors.avio_get_str16be = delegate(AVIOContext* pb, int maxlen, byte* buf, int buflen)
			{
				vectors.avio_get_str16be = FunctionResolver.GetFunctionDelegate<vectors.avio_get_str16be_delegate>("avformat", "avio_get_str16be", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_get_str16be_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_get_str16be(pb, maxlen, buf, buflen);
			};
			vectors.avio_get_str16le = delegate(AVIOContext* pb, int maxlen, byte* buf, int buflen)
			{
				vectors.avio_get_str16le = FunctionResolver.GetFunctionDelegate<vectors.avio_get_str16le_delegate>("avformat", "avio_get_str16le", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_get_str16le_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_get_str16le(pb, maxlen, buf, buflen);
			};
			vectors.avio_handshake = delegate(AVIOContext* c)
			{
				vectors.avio_handshake = FunctionResolver.GetFunctionDelegate<vectors.avio_handshake_delegate>("avformat", "avio_handshake", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_handshake_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_handshake(c);
			};
			vectors.avio_open = delegate(AVIOContext** s, string url, int flags)
			{
				vectors.avio_open = FunctionResolver.GetFunctionDelegate<vectors.avio_open_delegate>("avformat", "avio_open", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_open_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_open(s, url, flags);
			};
			vectors.avio_open_dir = delegate(AVIODirContext** s, string url, AVDictionary** options)
			{
				vectors.avio_open_dir = FunctionResolver.GetFunctionDelegate<vectors.avio_open_dir_delegate>("avformat", "avio_open_dir", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_open_dir_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_open_dir(s, url, options);
			};
			vectors.avio_open_dyn_buf = delegate(AVIOContext** s)
			{
				vectors.avio_open_dyn_buf = FunctionResolver.GetFunctionDelegate<vectors.avio_open_dyn_buf_delegate>("avformat", "avio_open_dyn_buf", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_open_dyn_buf_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_open_dyn_buf(s);
			};
			vectors.avio_open2 = delegate(AVIOContext** s, string url, int flags, AVIOInterruptCB* int_cb, AVDictionary** options)
			{
				vectors.avio_open2 = FunctionResolver.GetFunctionDelegate<vectors.avio_open2_delegate>("avformat", "avio_open2", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_open2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_open2(s, url, flags, int_cb, options);
			};
			vectors.avio_pause = delegate(AVIOContext* h, int pause)
			{
				vectors.avio_pause = FunctionResolver.GetFunctionDelegate<vectors.avio_pause_delegate>("avformat", "avio_pause", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_pause_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_pause(h, pause);
			};
			vectors.avio_print_string_array = delegate(AVIOContext* s, byte*[] strings)
			{
				vectors.avio_print_string_array = FunctionResolver.GetFunctionDelegate<vectors.avio_print_string_array_delegate>("avformat", "avio_print_string_array", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_print_string_array_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_print_string_array(s, strings);
			};
			vectors.avio_printf = delegate(AVIOContext* s, string fmt)
			{
				vectors.avio_printf = FunctionResolver.GetFunctionDelegate<vectors.avio_printf_delegate>("avformat", "avio_printf", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_printf_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_printf(s, fmt);
			};
			vectors.avio_protocol_get_class = delegate(string name)
			{
				vectors.avio_protocol_get_class = FunctionResolver.GetFunctionDelegate<vectors.avio_protocol_get_class_delegate>("avformat", "avio_protocol_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_protocol_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_protocol_get_class(name);
			};
			vectors.avio_put_str = delegate(AVIOContext* s, string str)
			{
				vectors.avio_put_str = FunctionResolver.GetFunctionDelegate<vectors.avio_put_str_delegate>("avformat", "avio_put_str", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_put_str_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_put_str(s, str);
			};
			vectors.avio_put_str16be = delegate(AVIOContext* s, string str)
			{
				vectors.avio_put_str16be = FunctionResolver.GetFunctionDelegate<vectors.avio_put_str16be_delegate>("avformat", "avio_put_str16be", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_put_str16be_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_put_str16be(s, str);
			};
			vectors.avio_put_str16le = delegate(AVIOContext* s, string str)
			{
				vectors.avio_put_str16le = FunctionResolver.GetFunctionDelegate<vectors.avio_put_str16le_delegate>("avformat", "avio_put_str16le", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_put_str16le_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_put_str16le(s, str);
			};
			vectors.avio_r8 = delegate(AVIOContext* s)
			{
				vectors.avio_r8 = FunctionResolver.GetFunctionDelegate<vectors.avio_r8_delegate>("avformat", "avio_r8", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_r8_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_r8(s);
			};
			vectors.avio_rb16 = delegate(AVIOContext* s)
			{
				vectors.avio_rb16 = FunctionResolver.GetFunctionDelegate<vectors.avio_rb16_delegate>("avformat", "avio_rb16", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_rb16_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_rb16(s);
			};
			vectors.avio_rb24 = delegate(AVIOContext* s)
			{
				vectors.avio_rb24 = FunctionResolver.GetFunctionDelegate<vectors.avio_rb24_delegate>("avformat", "avio_rb24", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_rb24_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_rb24(s);
			};
			vectors.avio_rb32 = delegate(AVIOContext* s)
			{
				vectors.avio_rb32 = FunctionResolver.GetFunctionDelegate<vectors.avio_rb32_delegate>("avformat", "avio_rb32", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_rb32_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_rb32(s);
			};
			vectors.avio_rb64 = delegate(AVIOContext* s)
			{
				vectors.avio_rb64 = FunctionResolver.GetFunctionDelegate<vectors.avio_rb64_delegate>("avformat", "avio_rb64", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_rb64_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_rb64(s);
			};
			vectors.avio_read = delegate(AVIOContext* s, byte* buf, int size)
			{
				vectors.avio_read = FunctionResolver.GetFunctionDelegate<vectors.avio_read_delegate>("avformat", "avio_read", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_read_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_read(s, buf, size);
			};
			vectors.avio_read_dir = delegate(AVIODirContext* s, AVIODirEntry** next)
			{
				vectors.avio_read_dir = FunctionResolver.GetFunctionDelegate<vectors.avio_read_dir_delegate>("avformat", "avio_read_dir", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_read_dir_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_read_dir(s, next);
			};
			vectors.avio_read_partial = delegate(AVIOContext* s, byte* buf, int size)
			{
				vectors.avio_read_partial = FunctionResolver.GetFunctionDelegate<vectors.avio_read_partial_delegate>("avformat", "avio_read_partial", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_read_partial_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_read_partial(s, buf, size);
			};
			vectors.avio_read_to_bprint = delegate(AVIOContext* h, AVBPrint* pb, ulong max_size)
			{
				vectors.avio_read_to_bprint = FunctionResolver.GetFunctionDelegate<vectors.avio_read_to_bprint_delegate>("avformat", "avio_read_to_bprint", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_read_to_bprint_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_read_to_bprint(h, pb, max_size);
			};
			vectors.avio_rl16 = delegate(AVIOContext* s)
			{
				vectors.avio_rl16 = FunctionResolver.GetFunctionDelegate<vectors.avio_rl16_delegate>("avformat", "avio_rl16", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_rl16_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_rl16(s);
			};
			vectors.avio_rl24 = delegate(AVIOContext* s)
			{
				vectors.avio_rl24 = FunctionResolver.GetFunctionDelegate<vectors.avio_rl24_delegate>("avformat", "avio_rl24", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_rl24_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_rl24(s);
			};
			vectors.avio_rl32 = delegate(AVIOContext* s)
			{
				vectors.avio_rl32 = FunctionResolver.GetFunctionDelegate<vectors.avio_rl32_delegate>("avformat", "avio_rl32", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_rl32_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_rl32(s);
			};
			vectors.avio_rl64 = delegate(AVIOContext* s)
			{
				vectors.avio_rl64 = FunctionResolver.GetFunctionDelegate<vectors.avio_rl64_delegate>("avformat", "avio_rl64", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_rl64_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_rl64(s);
			};
			vectors.avio_seek = delegate(AVIOContext* s, long offset, int whence)
			{
				vectors.avio_seek = FunctionResolver.GetFunctionDelegate<vectors.avio_seek_delegate>("avformat", "avio_seek", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_seek_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_seek(s, offset, whence);
			};
			vectors.avio_seek_time = delegate(AVIOContext* h, int stream_index, long timestamp, int flags)
			{
				vectors.avio_seek_time = FunctionResolver.GetFunctionDelegate<vectors.avio_seek_time_delegate>("avformat", "avio_seek_time", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_seek_time_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_seek_time(h, stream_index, timestamp, flags);
			};
			vectors.avio_size = delegate(AVIOContext* s)
			{
				vectors.avio_size = FunctionResolver.GetFunctionDelegate<vectors.avio_size_delegate>("avformat", "avio_size", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_size_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_size(s);
			};
			vectors.avio_skip = delegate(AVIOContext* s, long offset)
			{
				vectors.avio_skip = FunctionResolver.GetFunctionDelegate<vectors.avio_skip_delegate>("avformat", "avio_skip", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_skip_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_skip(s, offset);
			};
			vectors.avio_vprintf = delegate(AVIOContext* s, string fmt, byte* ap)
			{
				vectors.avio_vprintf = FunctionResolver.GetFunctionDelegate<vectors.avio_vprintf_delegate>("avformat", "avio_vprintf", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_vprintf_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avio_vprintf(s, fmt, ap);
			};
			vectors.avio_w8 = delegate(AVIOContext* s, int b)
			{
				vectors.avio_w8 = FunctionResolver.GetFunctionDelegate<vectors.avio_w8_delegate>("avformat", "avio_w8", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_w8_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_w8(s, b);
			};
			vectors.avio_wb16 = delegate(AVIOContext* s, uint val)
			{
				vectors.avio_wb16 = FunctionResolver.GetFunctionDelegate<vectors.avio_wb16_delegate>("avformat", "avio_wb16", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_wb16_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_wb16(s, val);
			};
			vectors.avio_wb24 = delegate(AVIOContext* s, uint val)
			{
				vectors.avio_wb24 = FunctionResolver.GetFunctionDelegate<vectors.avio_wb24_delegate>("avformat", "avio_wb24", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_wb24_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_wb24(s, val);
			};
			vectors.avio_wb32 = delegate(AVIOContext* s, uint val)
			{
				vectors.avio_wb32 = FunctionResolver.GetFunctionDelegate<vectors.avio_wb32_delegate>("avformat", "avio_wb32", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_wb32_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_wb32(s, val);
			};
			vectors.avio_wb64 = delegate(AVIOContext* s, ulong val)
			{
				vectors.avio_wb64 = FunctionResolver.GetFunctionDelegate<vectors.avio_wb64_delegate>("avformat", "avio_wb64", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_wb64_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_wb64(s, val);
			};
			vectors.avio_wl16 = delegate(AVIOContext* s, uint val)
			{
				vectors.avio_wl16 = FunctionResolver.GetFunctionDelegate<vectors.avio_wl16_delegate>("avformat", "avio_wl16", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_wl16_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_wl16(s, val);
			};
			vectors.avio_wl24 = delegate(AVIOContext* s, uint val)
			{
				vectors.avio_wl24 = FunctionResolver.GetFunctionDelegate<vectors.avio_wl24_delegate>("avformat", "avio_wl24", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_wl24_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_wl24(s, val);
			};
			vectors.avio_wl32 = delegate(AVIOContext* s, uint val)
			{
				vectors.avio_wl32 = FunctionResolver.GetFunctionDelegate<vectors.avio_wl32_delegate>("avformat", "avio_wl32", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_wl32_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_wl32(s, val);
			};
			vectors.avio_wl64 = delegate(AVIOContext* s, ulong val)
			{
				vectors.avio_wl64 = FunctionResolver.GetFunctionDelegate<vectors.avio_wl64_delegate>("avformat", "avio_wl64", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_wl64_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_wl64(s, val);
			};
			vectors.avio_write = delegate(AVIOContext* s, byte* buf, int size)
			{
				vectors.avio_write = FunctionResolver.GetFunctionDelegate<vectors.avio_write_delegate>("avformat", "avio_write", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_write_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_write(s, buf, size);
			};
			vectors.avio_write_marker = delegate(AVIOContext* s, long time, AVIODataMarkerType type)
			{
				vectors.avio_write_marker = FunctionResolver.GetFunctionDelegate<vectors.avio_write_marker_delegate>("avformat", "avio_write_marker", ThrowErrorIfFunctionNotFound) ?? ((vectors.avio_write_marker_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avio_write_marker(s, time, type);
			};
			vectors.avsubtitle_free = delegate(AVSubtitle* sub)
			{
				vectors.avsubtitle_free = FunctionResolver.GetFunctionDelegate<vectors.avsubtitle_free_delegate>("avcodec", "avsubtitle_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.avsubtitle_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.avsubtitle_free(sub);
			};
			vectors.avutil_configuration = delegate
			{
				vectors.avutil_configuration = FunctionResolver.GetFunctionDelegate<vectors.avutil_configuration_delegate>("avutil", "avutil_configuration", ThrowErrorIfFunctionNotFound) ?? ((vectors.avutil_configuration_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avutil_configuration();
			};
			vectors.avutil_license = delegate
			{
				vectors.avutil_license = FunctionResolver.GetFunctionDelegate<vectors.avutil_license_delegate>("avutil", "avutil_license", ThrowErrorIfFunctionNotFound) ?? ((vectors.avutil_license_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avutil_license();
			};
			vectors.avutil_version = delegate
			{
				vectors.avutil_version = FunctionResolver.GetFunctionDelegate<vectors.avutil_version_delegate>("avutil", "avutil_version", ThrowErrorIfFunctionNotFound) ?? ((vectors.avutil_version_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.avutil_version();
			};
			vectors.swr_alloc = delegate
			{
				vectors.swr_alloc = FunctionResolver.GetFunctionDelegate<vectors.swr_alloc_delegate>("swresample", "swr_alloc", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_alloc_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_alloc();
			};
			vectors.swr_alloc_set_opts2 = delegate(SwrContext** ps, AVChannelLayout* out_ch_layout, AVSampleFormat out_sample_fmt, int out_sample_rate, AVChannelLayout* in_ch_layout, AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void* log_ctx)
			{
				vectors.swr_alloc_set_opts2 = FunctionResolver.GetFunctionDelegate<vectors.swr_alloc_set_opts2_delegate>("swresample", "swr_alloc_set_opts2", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_alloc_set_opts2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_alloc_set_opts2(ps, out_ch_layout, out_sample_fmt, out_sample_rate, in_ch_layout, in_sample_fmt, in_sample_rate, log_offset, log_ctx);
			};
			vectors.swr_build_matrix2 = delegate(AVChannelLayout* in_layout, AVChannelLayout* out_layout, double center_mix_level, double surround_mix_level, double lfe_mix_level, double maxval, double rematrix_volume, double* matrix, long stride, AVMatrixEncoding matrix_encoding, void* log_context)
			{
				vectors.swr_build_matrix2 = FunctionResolver.GetFunctionDelegate<vectors.swr_build_matrix2_delegate>("swresample", "swr_build_matrix2", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_build_matrix2_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_build_matrix2(in_layout, out_layout, center_mix_level, surround_mix_level, lfe_mix_level, maxval, rematrix_volume, matrix, stride, matrix_encoding, log_context);
			};
			vectors.swr_close = delegate(SwrContext* s)
			{
				vectors.swr_close = FunctionResolver.GetFunctionDelegate<vectors.swr_close_delegate>("swresample", "swr_close", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_close_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.swr_close(s);
			};
			vectors.swr_config_frame = delegate(SwrContext* swr, AVFrame* @out, AVFrame* @in)
			{
				vectors.swr_config_frame = FunctionResolver.GetFunctionDelegate<vectors.swr_config_frame_delegate>("swresample", "swr_config_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_config_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_config_frame(swr, @out, @in);
			};
			vectors.swr_convert = delegate(SwrContext* s, byte** @out, int out_count, byte** @in, int in_count)
			{
				vectors.swr_convert = FunctionResolver.GetFunctionDelegate<vectors.swr_convert_delegate>("swresample", "swr_convert", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_convert_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_convert(s, @out, out_count, @in, in_count);
			};
			vectors.swr_convert_frame = delegate(SwrContext* swr, AVFrame* output, AVFrame* input)
			{
				vectors.swr_convert_frame = FunctionResolver.GetFunctionDelegate<vectors.swr_convert_frame_delegate>("swresample", "swr_convert_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_convert_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_convert_frame(swr, output, input);
			};
			vectors.swr_drop_output = delegate(SwrContext* s, int count)
			{
				vectors.swr_drop_output = FunctionResolver.GetFunctionDelegate<vectors.swr_drop_output_delegate>("swresample", "swr_drop_output", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_drop_output_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_drop_output(s, count);
			};
			vectors.swr_free = delegate(SwrContext** s)
			{
				vectors.swr_free = FunctionResolver.GetFunctionDelegate<vectors.swr_free_delegate>("swresample", "swr_free", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_free_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.swr_free(s);
			};
			vectors.swr_get_class = delegate
			{
				vectors.swr_get_class = FunctionResolver.GetFunctionDelegate<vectors.swr_get_class_delegate>("swresample", "swr_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_get_class();
			};
			vectors.swr_get_delay = delegate(SwrContext* s, long @base)
			{
				vectors.swr_get_delay = FunctionResolver.GetFunctionDelegate<vectors.swr_get_delay_delegate>("swresample", "swr_get_delay", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_get_delay_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_get_delay(s, @base);
			};
			vectors.swr_get_out_samples = delegate(SwrContext* s, int in_samples)
			{
				vectors.swr_get_out_samples = FunctionResolver.GetFunctionDelegate<vectors.swr_get_out_samples_delegate>("swresample", "swr_get_out_samples", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_get_out_samples_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_get_out_samples(s, in_samples);
			};
			vectors.swr_init = delegate(SwrContext* s)
			{
				vectors.swr_init = FunctionResolver.GetFunctionDelegate<vectors.swr_init_delegate>("swresample", "swr_init", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_init_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_init(s);
			};
			vectors.swr_inject_silence = delegate(SwrContext* s, int count)
			{
				vectors.swr_inject_silence = FunctionResolver.GetFunctionDelegate<vectors.swr_inject_silence_delegate>("swresample", "swr_inject_silence", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_inject_silence_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_inject_silence(s, count);
			};
			vectors.swr_is_initialized = delegate(SwrContext* s)
			{
				vectors.swr_is_initialized = FunctionResolver.GetFunctionDelegate<vectors.swr_is_initialized_delegate>("swresample", "swr_is_initialized", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_is_initialized_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_is_initialized(s);
			};
			vectors.swr_next_pts = delegate(SwrContext* s, long pts)
			{
				vectors.swr_next_pts = FunctionResolver.GetFunctionDelegate<vectors.swr_next_pts_delegate>("swresample", "swr_next_pts", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_next_pts_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_next_pts(s, pts);
			};
			vectors.swr_set_channel_mapping = delegate(SwrContext* s, int* channel_map)
			{
				vectors.swr_set_channel_mapping = FunctionResolver.GetFunctionDelegate<vectors.swr_set_channel_mapping_delegate>("swresample", "swr_set_channel_mapping", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_set_channel_mapping_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_set_channel_mapping(s, channel_map);
			};
			vectors.swr_set_compensation = delegate(SwrContext* s, int sample_delta, int compensation_distance)
			{
				vectors.swr_set_compensation = FunctionResolver.GetFunctionDelegate<vectors.swr_set_compensation_delegate>("swresample", "swr_set_compensation", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_set_compensation_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_set_compensation(s, sample_delta, compensation_distance);
			};
			vectors.swr_set_matrix = delegate(SwrContext* s, double* matrix, int stride)
			{
				vectors.swr_set_matrix = FunctionResolver.GetFunctionDelegate<vectors.swr_set_matrix_delegate>("swresample", "swr_set_matrix", ThrowErrorIfFunctionNotFound) ?? ((vectors.swr_set_matrix_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swr_set_matrix(s, matrix, stride);
			};
			vectors.swresample_configuration = delegate
			{
				vectors.swresample_configuration = FunctionResolver.GetFunctionDelegate<vectors.swresample_configuration_delegate>("swresample", "swresample_configuration", ThrowErrorIfFunctionNotFound) ?? ((vectors.swresample_configuration_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swresample_configuration();
			};
			vectors.swresample_license = delegate
			{
				vectors.swresample_license = FunctionResolver.GetFunctionDelegate<vectors.swresample_license_delegate>("swresample", "swresample_license", ThrowErrorIfFunctionNotFound) ?? ((vectors.swresample_license_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swresample_license();
			};
			vectors.swresample_version = delegate
			{
				vectors.swresample_version = FunctionResolver.GetFunctionDelegate<vectors.swresample_version_delegate>("swresample", "swresample_version", ThrowErrorIfFunctionNotFound) ?? ((vectors.swresample_version_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swresample_version();
			};
			vectors.sws_alloc_context = delegate
			{
				vectors.sws_alloc_context = FunctionResolver.GetFunctionDelegate<vectors.sws_alloc_context_delegate>("swscale", "sws_alloc_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_alloc_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_alloc_context();
			};
			vectors.sws_allocVec = delegate(int length)
			{
				vectors.sws_allocVec = FunctionResolver.GetFunctionDelegate<vectors.sws_allocVec_delegate>("swscale", "sws_allocVec", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_allocVec_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_allocVec(length);
			};
			vectors.sws_convertPalette8ToPacked24 = delegate(byte* src, byte* dst, int num_pixels, byte* palette)
			{
				vectors.sws_convertPalette8ToPacked24 = FunctionResolver.GetFunctionDelegate<vectors.sws_convertPalette8ToPacked24_delegate>("swscale", "sws_convertPalette8ToPacked24", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_convertPalette8ToPacked24_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_convertPalette8ToPacked24(src, dst, num_pixels, palette);
			};
			vectors.sws_convertPalette8ToPacked32 = delegate(byte* src, byte* dst, int num_pixels, byte* palette)
			{
				vectors.sws_convertPalette8ToPacked32 = FunctionResolver.GetFunctionDelegate<vectors.sws_convertPalette8ToPacked32_delegate>("swscale", "sws_convertPalette8ToPacked32", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_convertPalette8ToPacked32_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_convertPalette8ToPacked32(src, dst, num_pixels, palette);
			};
			vectors.sws_frame_end = delegate(SwsContext* c)
			{
				vectors.sws_frame_end = FunctionResolver.GetFunctionDelegate<vectors.sws_frame_end_delegate>("swscale", "sws_frame_end", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_frame_end_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_frame_end(c);
			};
			vectors.sws_frame_setup = delegate(SwsContext* ctx, AVFrame* dst, AVFrame* src)
			{
				vectors.sws_frame_setup = FunctionResolver.GetFunctionDelegate<vectors.sws_frame_setup_delegate>("swscale", "sws_frame_setup", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_frame_setup_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_frame_setup(ctx, dst, src);
			};
			vectors.sws_frame_start = delegate(SwsContext* c, AVFrame* dst, AVFrame* src)
			{
				vectors.sws_frame_start = FunctionResolver.GetFunctionDelegate<vectors.sws_frame_start_delegate>("swscale", "sws_frame_start", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_frame_start_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_frame_start(c, dst, src);
			};
			vectors.sws_free_context = delegate(SwsContext** ctx)
			{
				vectors.sws_free_context = FunctionResolver.GetFunctionDelegate<vectors.sws_free_context_delegate>("swscale", "sws_free_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_free_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_free_context(ctx);
			};
			vectors.sws_freeContext = delegate(SwsContext* swsContext)
			{
				vectors.sws_freeContext = FunctionResolver.GetFunctionDelegate<vectors.sws_freeContext_delegate>("swscale", "sws_freeContext", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_freeContext_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_freeContext(swsContext);
			};
			vectors.sws_freeFilter = delegate(SwsFilter* filter)
			{
				vectors.sws_freeFilter = FunctionResolver.GetFunctionDelegate<vectors.sws_freeFilter_delegate>("swscale", "sws_freeFilter", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_freeFilter_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_freeFilter(filter);
			};
			vectors.sws_freeVec = delegate(SwsVector* a)
			{
				vectors.sws_freeVec = FunctionResolver.GetFunctionDelegate<vectors.sws_freeVec_delegate>("swscale", "sws_freeVec", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_freeVec_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_freeVec(a);
			};
			vectors.sws_get_class = delegate
			{
				vectors.sws_get_class = FunctionResolver.GetFunctionDelegate<vectors.sws_get_class_delegate>("swscale", "sws_get_class", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_get_class_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_get_class();
			};
			vectors.sws_getCachedContext = delegate(SwsContext* context, int srcW, int srcH, AVPixelFormat srcFormat, int dstW, int dstH, AVPixelFormat dstFormat, int flags, SwsFilter* srcFilter, SwsFilter* dstFilter, double* param)
			{
				vectors.sws_getCachedContext = FunctionResolver.GetFunctionDelegate<vectors.sws_getCachedContext_delegate>("swscale", "sws_getCachedContext", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_getCachedContext_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_getCachedContext(context, srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, srcFilter, dstFilter, param);
			};
			vectors.sws_getCoefficients = delegate(int colorspace)
			{
				vectors.sws_getCoefficients = FunctionResolver.GetFunctionDelegate<vectors.sws_getCoefficients_delegate>("swscale", "sws_getCoefficients", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_getCoefficients_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_getCoefficients(colorspace);
			};
			vectors.sws_getColorspaceDetails = delegate(SwsContext* c, int** inv_table, int* srcRange, int** table, int* dstRange, int* brightness, int* contrast, int* saturation)
			{
				vectors.sws_getColorspaceDetails = FunctionResolver.GetFunctionDelegate<vectors.sws_getColorspaceDetails_delegate>("swscale", "sws_getColorspaceDetails", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_getColorspaceDetails_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_getColorspaceDetails(c, inv_table, srcRange, table, dstRange, brightness, contrast, saturation);
			};
			vectors.sws_getContext = delegate(int srcW, int srcH, AVPixelFormat srcFormat, int dstW, int dstH, AVPixelFormat dstFormat, int flags, SwsFilter* srcFilter, SwsFilter* dstFilter, double* param)
			{
				vectors.sws_getContext = FunctionResolver.GetFunctionDelegate<vectors.sws_getContext_delegate>("swscale", "sws_getContext", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_getContext_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, srcFilter, dstFilter, param);
			};
			vectors.sws_getDefaultFilter = delegate(float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose)
			{
				vectors.sws_getDefaultFilter = FunctionResolver.GetFunctionDelegate<vectors.sws_getDefaultFilter_delegate>("swscale", "sws_getDefaultFilter", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_getDefaultFilter_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_getDefaultFilter(lumaGBlur, chromaGBlur, lumaSharpen, chromaSharpen, chromaHShift, chromaVShift, verbose);
			};
			vectors.sws_getGaussianVec = delegate(double variance, double quality)
			{
				vectors.sws_getGaussianVec = FunctionResolver.GetFunctionDelegate<vectors.sws_getGaussianVec_delegate>("swscale", "sws_getGaussianVec", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_getGaussianVec_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_getGaussianVec(variance, quality);
			};
			vectors.sws_init_context = delegate(SwsContext* sws_context, SwsFilter* srcFilter, SwsFilter* dstFilter)
			{
				vectors.sws_init_context = FunctionResolver.GetFunctionDelegate<vectors.sws_init_context_delegate>("swscale", "sws_init_context", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_init_context_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_init_context(sws_context, srcFilter, dstFilter);
			};
			vectors.sws_is_noop = delegate(AVFrame* dst, AVFrame* src)
			{
				vectors.sws_is_noop = FunctionResolver.GetFunctionDelegate<vectors.sws_is_noop_delegate>("swscale", "sws_is_noop", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_is_noop_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_is_noop(dst, src);
			};
			vectors.sws_isSupportedEndiannessConversion = delegate(AVPixelFormat pix_fmt)
			{
				vectors.sws_isSupportedEndiannessConversion = FunctionResolver.GetFunctionDelegate<vectors.sws_isSupportedEndiannessConversion_delegate>("swscale", "sws_isSupportedEndiannessConversion", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_isSupportedEndiannessConversion_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_isSupportedEndiannessConversion(pix_fmt);
			};
			vectors.sws_isSupportedInput = delegate(AVPixelFormat pix_fmt)
			{
				vectors.sws_isSupportedInput = FunctionResolver.GetFunctionDelegate<vectors.sws_isSupportedInput_delegate>("swscale", "sws_isSupportedInput", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_isSupportedInput_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_isSupportedInput(pix_fmt);
			};
			vectors.sws_isSupportedOutput = delegate(AVPixelFormat pix_fmt)
			{
				vectors.sws_isSupportedOutput = FunctionResolver.GetFunctionDelegate<vectors.sws_isSupportedOutput_delegate>("swscale", "sws_isSupportedOutput", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_isSupportedOutput_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_isSupportedOutput(pix_fmt);
			};
			vectors.sws_normalizeVec = delegate(SwsVector* a, double height)
			{
				vectors.sws_normalizeVec = FunctionResolver.GetFunctionDelegate<vectors.sws_normalizeVec_delegate>("swscale", "sws_normalizeVec", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_normalizeVec_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_normalizeVec(a, height);
			};
			vectors.sws_receive_slice = delegate(SwsContext* c, uint slice_start, uint slice_height)
			{
				vectors.sws_receive_slice = FunctionResolver.GetFunctionDelegate<vectors.sws_receive_slice_delegate>("swscale", "sws_receive_slice", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_receive_slice_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_receive_slice(c, slice_start, slice_height);
			};
			vectors.sws_receive_slice_alignment = delegate(SwsContext* c)
			{
				vectors.sws_receive_slice_alignment = FunctionResolver.GetFunctionDelegate<vectors.sws_receive_slice_alignment_delegate>("swscale", "sws_receive_slice_alignment", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_receive_slice_alignment_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_receive_slice_alignment(c);
			};
			vectors.sws_scale = delegate(SwsContext* c, byte*[] srcSlice, int[] srcStride, int srcSliceY, int srcSliceH, byte*[] dst, int[] dstStride)
			{
				vectors.sws_scale = FunctionResolver.GetFunctionDelegate<vectors.sws_scale_delegate>("swscale", "sws_scale", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_scale_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_scale(c, srcSlice, srcStride, srcSliceY, srcSliceH, dst, dstStride);
			};
			vectors.sws_scale_frame = delegate(SwsContext* c, AVFrame* dst, AVFrame* src)
			{
				vectors.sws_scale_frame = FunctionResolver.GetFunctionDelegate<vectors.sws_scale_frame_delegate>("swscale", "sws_scale_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_scale_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_scale_frame(c, dst, src);
			};
			vectors.sws_scaleVec = delegate(SwsVector* a, double scalar)
			{
				vectors.sws_scaleVec = FunctionResolver.GetFunctionDelegate<vectors.sws_scaleVec_delegate>("swscale", "sws_scaleVec", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_scaleVec_delegate)delegate
				{
					throw new NotSupportedException();
				});
				vectors.sws_scaleVec(a, scalar);
			};
			vectors.sws_send_slice = delegate(SwsContext* c, uint slice_start, uint slice_height)
			{
				vectors.sws_send_slice = FunctionResolver.GetFunctionDelegate<vectors.sws_send_slice_delegate>("swscale", "sws_send_slice", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_send_slice_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_send_slice(c, slice_start, slice_height);
			};
			vectors.sws_setColorspaceDetails = delegate(SwsContext* c, in int_array4 inv_table, int srcRange, in int_array4 table, int dstRange, int brightness, int contrast, int saturation)
			{
				vectors.sws_setColorspaceDetails = FunctionResolver.GetFunctionDelegate<vectors.sws_setColorspaceDetails_delegate>("swscale", "sws_setColorspaceDetails", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_setColorspaceDetails_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_setColorspaceDetails(c, in inv_table, srcRange, in table, dstRange, brightness, contrast, saturation);
			};
			vectors.sws_test_colorspace = delegate(AVColorSpace colorspace, int output)
			{
				vectors.sws_test_colorspace = FunctionResolver.GetFunctionDelegate<vectors.sws_test_colorspace_delegate>("swscale", "sws_test_colorspace", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_test_colorspace_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_test_colorspace(colorspace, output);
			};
			vectors.sws_test_format = delegate(AVPixelFormat format, int output)
			{
				vectors.sws_test_format = FunctionResolver.GetFunctionDelegate<vectors.sws_test_format_delegate>("swscale", "sws_test_format", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_test_format_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_test_format(format, output);
			};
			vectors.sws_test_frame = delegate(AVFrame* frame, int output)
			{
				vectors.sws_test_frame = FunctionResolver.GetFunctionDelegate<vectors.sws_test_frame_delegate>("swscale", "sws_test_frame", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_test_frame_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_test_frame(frame, output);
			};
			vectors.sws_test_primaries = delegate(AVColorPrimaries primaries, int output)
			{
				vectors.sws_test_primaries = FunctionResolver.GetFunctionDelegate<vectors.sws_test_primaries_delegate>("swscale", "sws_test_primaries", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_test_primaries_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_test_primaries(primaries, output);
			};
			vectors.sws_test_transfer = delegate(AVColorTransferCharacteristic trc, int output)
			{
				vectors.sws_test_transfer = FunctionResolver.GetFunctionDelegate<vectors.sws_test_transfer_delegate>("swscale", "sws_test_transfer", ThrowErrorIfFunctionNotFound) ?? ((vectors.sws_test_transfer_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.sws_test_transfer(trc, output);
			};
			vectors.swscale_configuration = delegate
			{
				vectors.swscale_configuration = FunctionResolver.GetFunctionDelegate<vectors.swscale_configuration_delegate>("swscale", "swscale_configuration", ThrowErrorIfFunctionNotFound) ?? ((vectors.swscale_configuration_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swscale_configuration();
			};
			vectors.swscale_license = delegate
			{
				vectors.swscale_license = FunctionResolver.GetFunctionDelegate<vectors.swscale_license_delegate>("swscale", "swscale_license", ThrowErrorIfFunctionNotFound) ?? ((vectors.swscale_license_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swscale_license();
			};
			vectors.swscale_version = delegate
			{
				vectors.swscale_version = FunctionResolver.GetFunctionDelegate<vectors.swscale_version_delegate>("swscale", "swscale_version", ThrowErrorIfFunctionNotFound) ?? ((vectors.swscale_version_delegate)delegate
				{
					throw new NotSupportedException();
				});
				return vectors.swscale_version();
			};
		}
	}
	public enum AVActiveFormatDescription
	{
		AV_AFD_SAME = 8,
		AV_AFD_4_3 = 9,
		AV_AFD_16_9 = 10,
		AV_AFD_14_9 = 11,
		AV_AFD_4_3_SP_14_9 = 13,
		AV_AFD_16_9_SP_14_9 = 14,
		AV_AFD_SP_4_3 = 15
	}
	public enum AVAppToDevMessageType
	{
		AV_APP_TO_DEV_NONE = 1313820229,
		AV_APP_TO_DEV_WINDOW_SIZE = 1195724621,
		AV_APP_TO_DEV_WINDOW_REPAINT = 1380274241,
		AV_APP_TO_DEV_PAUSE = 1346458912,
		AV_APP_TO_DEV_PLAY = 1347174745,
		AV_APP_TO_DEV_TOGGLE_PAUSE = 1346458964,
		AV_APP_TO_DEV_SET_VOLUME = 1398165324,
		AV_APP_TO_DEV_MUTE = 541939028,
		AV_APP_TO_DEV_UNMUTE = 1431131476,
		AV_APP_TO_DEV_TOGGLE_MUTE = 1414354260,
		AV_APP_TO_DEV_GET_VOLUME = 1196838732,
		AV_APP_TO_DEV_GET_MUTE = 1196250452
	}
	public enum AVAudioServiceType
	{
		AV_AUDIO_SERVICE_TYPE_MAIN,
		AV_AUDIO_SERVICE_TYPE_EFFECTS,
		AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED,
		AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED,
		AV_AUDIO_SERVICE_TYPE_DIALOGUE,
		AV_AUDIO_SERVICE_TYPE_COMMENTARY,
		AV_AUDIO_SERVICE_TYPE_EMERGENCY,
		AV_AUDIO_SERVICE_TYPE_VOICE_OVER,
		AV_AUDIO_SERVICE_TYPE_KARAOKE,
		AV_AUDIO_SERVICE_TYPE_NB
	}
	public enum AVChannel
	{
		AV_CHAN_NONE = -1,
		AV_CHAN_FRONT_LEFT = 0,
		AV_CHAN_FRONT_RIGHT = 1,
		AV_CHAN_FRONT_CENTER = 2,
		AV_CHAN_LOW_FREQUENCY = 3,
		AV_CHAN_BACK_LEFT = 4,
		AV_CHAN_BACK_RIGHT = 5,
		AV_CHAN_FRONT_LEFT_OF_CENTER = 6,
		AV_CHAN_FRONT_RIGHT_OF_CENTER = 7,
		AV_CHAN_BACK_CENTER = 8,
		AV_CHAN_SIDE_LEFT = 9,
		AV_CHAN_SIDE_RIGHT = 10,
		AV_CHAN_TOP_CENTER = 11,
		AV_CHAN_TOP_FRONT_LEFT = 12,
		AV_CHAN_TOP_FRONT_CENTER = 13,
		AV_CHAN_TOP_FRONT_RIGHT = 14,
		AV_CHAN_TOP_BACK_LEFT = 15,
		AV_CHAN_TOP_BACK_CENTER = 16,
		AV_CHAN_TOP_BACK_RIGHT = 17,
		AV_CHAN_STEREO_LEFT = 29,
		AV_CHAN_STEREO_RIGHT = 30,
		AV_CHAN_WIDE_LEFT = 31,
		AV_CHAN_WIDE_RIGHT = 32,
		AV_CHAN_SURROUND_DIRECT_LEFT = 33,
		AV_CHAN_SURROUND_DIRECT_RIGHT = 34,
		AV_CHAN_LOW_FREQUENCY_2 = 35,
		AV_CHAN_TOP_SIDE_LEFT = 36,
		AV_CHAN_TOP_SIDE_RIGHT = 37,
		AV_CHAN_BOTTOM_FRONT_CENTER = 38,
		AV_CHAN_BOTTOM_FRONT_LEFT = 39,
		AV_CHAN_BOTTOM_FRONT_RIGHT = 40,
		AV_CHAN_SIDE_SURROUND_LEFT = 41,
		AV_CHAN_SIDE_SURROUND_RIGHT = 42,
		AV_CHAN_TOP_SURROUND_LEFT = 43,
		AV_CHAN_TOP_SURROUND_RIGHT = 44,
		AV_CHAN_BINAURAL_LEFT = 61,
		AV_CHAN_BINAURAL_RIGHT = 62,
		AV_CHAN_UNUSED = 512,
		AV_CHAN_UNKNOWN = 768,
		AV_CHAN_AMBISONIC_BASE = 1024,
		AV_CHAN_AMBISONIC_END = 2047
	}
	public enum AVChannelOrder
	{
		AV_CHANNEL_ORDER_UNSPEC,
		AV_CHANNEL_ORDER_NATIVE,
		AV_CHANNEL_ORDER_CUSTOM,
		AV_CHANNEL_ORDER_AMBISONIC,
		FF_CHANNEL_ORDER_NB
	}
	public enum AVChromaLocation
	{
		AVCHROMA_LOC_UNSPECIFIED,
		AVCHROMA_LOC_LEFT,
		AVCHROMA_LOC_CENTER,
		AVCHROMA_LOC_TOPLEFT,
		AVCHROMA_LOC_TOP,
		AVCHROMA_LOC_BOTTOMLEFT,
		AVCHROMA_LOC_BOTTOM,
		AVCHROMA_LOC_NB
	}
	public enum AVClassCategory
	{
		AV_CLASS_CATEGORY_NA = 0,
		AV_CLASS_CATEGORY_INPUT = 1,
		AV_CLASS_CATEGORY_OUTPUT = 2,
		AV_CLASS_CATEGORY_MUXER = 3,
		AV_CLASS_CATEGORY_DEMUXER = 4,
		AV_CLASS_CATEGORY_ENCODER = 5,
		AV_CLASS_CATEGORY_DECODER = 6,
		AV_CLASS_CATEGORY_FILTER = 7,
		AV_CLASS_CATEGORY_BITSTREAM_FILTER = 8,
		AV_CLASS_CATEGORY_SWSCALER = 9,
		AV_CLASS_CATEGORY_SWRESAMPLER = 10,
		AV_CLASS_CATEGORY_HWDEVICE = 11,
		AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = 40,
		AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT = 41,
		AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT = 42,
		AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT = 43,
		AV_CLASS_CATEGORY_DEVICE_OUTPUT = 44,
		AV_CLASS_CATEGORY_DEVICE_INPUT = 45,
		AV_CLASS_CATEGORY_NB = 46
	}
	public enum AVClassStateFlags
	{
		AV_CLASS_STATE_INITIALIZED = 1
	}
	public enum AVCodecConfig
	{
		AV_CODEC_CONFIG_PIX_FORMAT,
		AV_CODEC_CONFIG_FRAME_RATE,
		AV_CODEC_CONFIG_SAMPLE_RATE,
		AV_CODEC_CONFIG_SAMPLE_FORMAT,
		AV_CODEC_CONFIG_CHANNEL_LAYOUT,
		AV_CODEC_CONFIG_COLOR_RANGE,
		AV_CODEC_CONFIG_COLOR_SPACE
	}
	public enum AVCodecID
	{
		AV_CODEC_ID_NONE = 0,
		AV_CODEC_ID_MPEG1VIDEO = 1,
		AV_CODEC_ID_MPEG2VIDEO = 2,
		AV_CODEC_ID_H261 = 3,
		AV_CODEC_ID_H263 = 4,
		AV_CODEC_ID_RV10 = 5,
		AV_CODEC_ID_RV20 = 6,
		AV_CODEC_ID_MJPEG = 7,
		AV_CODEC_ID_MJPEGB = 8,
		AV_CODEC_ID_LJPEG = 9,
		AV_CODEC_ID_SP5X = 10,
		AV_CODEC_ID_JPEGLS = 11,
		AV_CODEC_ID_MPEG4 = 12,
		AV_CODEC_ID_RAWVIDEO = 13,
		AV_CODEC_ID_MSMPEG4V1 = 14,
		AV_CODEC_ID_MSMPEG4V2 = 15,
		AV_CODEC_ID_MSMPEG4V3 = 16,
		AV_CODEC_ID_WMV1 = 17,
		AV_CODEC_ID_WMV2 = 18,
		AV_CODEC_ID_H263P = 19,
		AV_CODEC_ID_H263I = 20,
		AV_CODEC_ID_FLV1 = 21,
		AV_CODEC_ID_SVQ1 = 22,
		AV_CODEC_ID_SVQ3 = 23,
		AV_CODEC_ID_DVVIDEO = 24,
		AV_CODEC_ID_HUFFYUV = 25,
		AV_CODEC_ID_CYUV = 26,
		AV_CODEC_ID_H264 = 27,
		AV_CODEC_ID_INDEO3 = 28,
		AV_CODEC_ID_VP3 = 29,
		AV_CODEC_ID_THEORA = 30,
		AV_CODEC_ID_ASV1 = 31,
		AV_CODEC_ID_ASV2 = 32,
		AV_CODEC_ID_FFV1 = 33,
		AV_CODEC_ID_4XM = 34,
		AV_CODEC_ID_VCR1 = 35,
		AV_CODEC_ID_CLJR = 36,
		AV_CODEC_ID_MDEC = 37,
		AV_CODEC_ID_ROQ = 38,
		AV_CODEC_ID_INTERPLAY_VIDEO = 39,
		AV_CODEC_ID_XAN_WC3 = 40,
		AV_CODEC_ID_XAN_WC4 = 41,
		AV_CODEC_ID_RPZA = 42,
		AV_CODEC_ID_CINEPAK = 43,
		AV_CODEC_ID_WS_VQA = 44,
		AV_CODEC_ID_MSRLE = 45,
		AV_CODEC_ID_MSVIDEO1 = 46,
		AV_CODEC_ID_IDCIN = 47,
		AV_CODEC_ID_8BPS = 48,
		AV_CODEC_ID_SMC = 49,
		AV_CODEC_ID_FLIC = 50,
		AV_CODEC_ID_TRUEMOTION1 = 51,
		AV_CODEC_ID_VMDVIDEO = 52,
		AV_CODEC_ID_MSZH = 53,
		AV_CODEC_ID_ZLIB = 54,
		AV_CODEC_ID_QTRLE = 55,
		AV_CODEC_ID_TSCC = 56,
		AV_CODEC_ID_ULTI = 57,
		AV_CODEC_ID_QDRAW = 58,
		AV_CODEC_ID_VIXL = 59,
		AV_CODEC_ID_QPEG = 60,
		AV_CODEC_ID_PNG = 61,
		AV_CODEC_ID_PPM = 62,
		AV_CODEC_ID_PBM = 63,
		AV_CODEC_ID_PGM = 64,
		AV_CODEC_ID_PGMYUV = 65,
		AV_CODEC_ID_PAM = 66,
		AV_CODEC_ID_FFVHUFF = 67,
		AV_CODEC_ID_RV30 = 68,
		AV_CODEC_ID_RV40 = 69,
		AV_CODEC_ID_VC1 = 70,
		AV_CODEC_ID_WMV3 = 71,
		AV_CODEC_ID_LOCO = 72,
		AV_CODEC_ID_WNV1 = 73,
		AV_CODEC_ID_AASC = 74,
		AV_CODEC_ID_INDEO2 = 75,
		AV_CODEC_ID_FRAPS = 76,
		AV_CODEC_ID_TRUEMOTION2 = 77,
		AV_CODEC_ID_BMP = 78,
		AV_CODEC_ID_CSCD = 79,
		AV_CODEC_ID_MMVIDEO = 80,
		AV_CODEC_ID_ZMBV = 81,
		AV_CODEC_ID_AVS = 82,
		AV_CODEC_ID_SMACKVIDEO = 83,
		AV_CODEC_ID_NUV = 84,
		AV_CODEC_ID_KMVC = 85,
		AV_CODEC_ID_FLASHSV = 86,
		AV_CODEC_ID_CAVS = 87,
		AV_CODEC_ID_JPEG2000 = 88,
		AV_CODEC_ID_VMNC = 89,
		AV_CODEC_ID_VP5 = 90,
		AV_CODEC_ID_VP6 = 91,
		AV_CODEC_ID_VP6F = 92,
		AV_CODEC_ID_TARGA = 93,
		AV_CODEC_ID_DSICINVIDEO = 94,
		AV_CODEC_ID_TIERTEXSEQVIDEO = 95,
		AV_CODEC_ID_TIFF = 96,
		AV_CODEC_ID_GIF = 97,
		AV_CODEC_ID_DXA = 98,
		AV_CODEC_ID_DNXHD = 99,
		AV_CODEC_ID_THP = 100,
		AV_CODEC_ID_SGI = 101,
		AV_CODEC_ID_C93 = 102,
		AV_CODEC_ID_BETHSOFTVID = 103,
		AV_CODEC_ID_PTX = 104,
		AV_CODEC_ID_TXD = 105,
		AV_CODEC_ID_VP6A = 106,
		AV_CODEC_ID_AMV = 107,
		AV_CODEC_ID_VB = 108,
		AV_CODEC_ID_PCX = 109,
		AV_CODEC_ID_SUNRAST = 110,
		AV_CODEC_ID_INDEO4 = 111,
		AV_CODEC_ID_INDEO5 = 112,
		AV_CODEC_ID_MIMIC = 113,
		AV_CODEC_ID_RL2 = 114,
		AV_CODEC_ID_ESCAPE124 = 115,
		AV_CODEC_ID_DIRAC = 116,
		AV_CODEC_ID_BFI = 117,
		AV_CODEC_ID_CMV = 118,
		AV_CODEC_ID_MOTIONPIXELS = 119,
		AV_CODEC_ID_TGV = 120,
		AV_CODEC_ID_TGQ = 121,
		AV_CODEC_ID_TQI = 122,
		AV_CODEC_ID_AURA = 123,
		AV_CODEC_ID_AURA2 = 124,
		AV_CODEC_ID_V210X = 125,
		AV_CODEC_ID_TMV = 126,
		AV_CODEC_ID_V210 = 127,
		AV_CODEC_ID_DPX = 128,
		AV_CODEC_ID_MAD = 129,
		AV_CODEC_ID_FRWU = 130,
		AV_CODEC_ID_FLASHSV2 = 131,
		AV_CODEC_ID_CDGRAPHICS = 132,
		AV_CODEC_ID_R210 = 133,
		AV_CODEC_ID_ANM = 134,
		AV_CODEC_ID_BINKVIDEO = 135,
		AV_CODEC_ID_IFF_ILBM = 136,
		AV_CODEC_ID_KGV1 = 137,
		AV_CODEC_ID_YOP = 138,
		AV_CODEC_ID_VP8 = 139,
		AV_CODEC_ID_PICTOR = 140,
		AV_CODEC_ID_ANSI = 141,
		AV_CODEC_ID_A64_MULTI = 142,
		AV_CODEC_ID_A64_MULTI5 = 143,
		AV_CODEC_ID_R10K = 144,
		AV_CODEC_ID_MXPEG = 145,
		AV_CODEC_ID_LAGARITH = 146,
		AV_CODEC_ID_PRORES = 147,
		AV_CODEC_ID_JV = 148,
		AV_CODEC_ID_DFA = 149,
		AV_CODEC_ID_WMV3IMAGE = 150,
		AV_CODEC_ID_VC1IMAGE = 151,
		AV_CODEC_ID_UTVIDEO = 152,
		AV_CODEC_ID_BMV_VIDEO = 153,
		AV_CODEC_ID_VBLE = 154,
		AV_CODEC_ID_DXTORY = 155,
		AV_CODEC_ID_V410 = 156,
		AV_CODEC_ID_XWD = 157,
		AV_CODEC_ID_CDXL = 158,
		AV_CODEC_ID_XBM = 159,
		AV_CODEC_ID_ZEROCODEC = 160,
		AV_CODEC_ID_MSS1 = 161,
		AV_CODEC_ID_MSA1 = 162,
		AV_CODEC_ID_TSCC2 = 163,
		AV_CODEC_ID_MTS2 = 164,
		AV_CODEC_ID_CLLC = 165,
		AV_CODEC_ID_MSS2 = 166,
		AV_CODEC_ID_VP9 = 167,
		AV_CODEC_ID_AIC = 168,
		AV_CODEC_ID_ESCAPE130 = 169,
		AV_CODEC_ID_G2M = 170,
		AV_CODEC_ID_WEBP = 171,
		AV_CODEC_ID_HNM4_VIDEO = 172,
		AV_CODEC_ID_HEVC = 173,
		AV_CODEC_ID_FIC = 174,
		AV_CODEC_ID_ALIAS_PIX = 175,
		AV_CODEC_ID_BRENDER_PIX = 176,
		AV_CODEC_ID_PAF_VIDEO = 177,
		AV_CODEC_ID_EXR = 178,
		AV_CODEC_ID_VP7 = 179,
		AV_CODEC_ID_SANM = 180,
		AV_CODEC_ID_SGIRLE = 181,
		AV_CODEC_ID_MVC1 = 182,
		AV_CODEC_ID_MVC2 = 183,
		AV_CODEC_ID_HQX = 184,
		AV_CODEC_ID_TDSC = 185,
		AV_CODEC_ID_HQ_HQA = 186,
		AV_CODEC_ID_HAP = 187,
		AV_CODEC_ID_DDS = 188,
		AV_CODEC_ID_DXV = 189,
		AV_CODEC_ID_SCREENPRESSO = 190,
		AV_CODEC_ID_RSCC = 191,
		AV_CODEC_ID_AVS2 = 192,
		AV_CODEC_ID_PGX = 193,
		AV_CODEC_ID_AVS3 = 194,
		AV_CODEC_ID_MSP2 = 195,
		AV_CODEC_ID_VVC = 196,
		AV_CODEC_ID_Y41P = 197,
		AV_CODEC_ID_AVRP = 198,
		AV_CODEC_ID_012V = 199,
		AV_CODEC_ID_AVUI = 200,
		AV_CODEC_ID_TARGA_Y216 = 201,
		AV_CODEC_ID_V308 = 202,
		AV_CODEC_ID_V408 = 203,
		AV_CODEC_ID_YUV4 = 204,
		AV_CODEC_ID_AVRN = 205,
		AV_CODEC_ID_CPIA = 206,
		AV_CODEC_ID_XFACE = 207,
		AV_CODEC_ID_SNOW = 208,
		AV_CODEC_ID_SMVJPEG = 209,
		AV_CODEC_ID_APNG = 210,
		AV_CODEC_ID_DAALA = 211,
		AV_CODEC_ID_CFHD = 212,
		AV_CODEC_ID_TRUEMOTION2RT = 213,
		AV_CODEC_ID_M101 = 214,
		AV_CODEC_ID_MAGICYUV = 215,
		AV_CODEC_ID_SHEERVIDEO = 216,
		AV_CODEC_ID_YLC = 217,
		AV_CODEC_ID_PSD = 218,
		AV_CODEC_ID_PIXLET = 219,
		AV_CODEC_ID_SPEEDHQ = 220,
		AV_CODEC_ID_FMVC = 221,
		AV_CODEC_ID_SCPR = 222,
		AV_CODEC_ID_CLEARVIDEO = 223,
		AV_CODEC_ID_XPM = 224,
		AV_CODEC_ID_AV1 = 225,
		AV_CODEC_ID_BITPACKED = 226,
		AV_CODEC_ID_MSCC = 227,
		AV_CODEC_ID_SRGC = 228,
		AV_CODEC_ID_SVG = 229,
		AV_CODEC_ID_GDV = 230,
		AV_CODEC_ID_FITS = 231,
		AV_CODEC_ID_IMM4 = 232,
		AV_CODEC_ID_PROSUMER = 233,
		AV_CODEC_ID_MWSC = 234,
		AV_CODEC_ID_WCMV = 235,
		AV_CODEC_ID_RASC = 236,
		AV_CODEC_ID_HYMT = 237,
		AV_CODEC_ID_ARBC = 238,
		AV_CODEC_ID_AGM = 239,
		AV_CODEC_ID_LSCR = 240,
		AV_CODEC_ID_VP4 = 241,
		AV_CODEC_ID_IMM5 = 242,
		AV_CODEC_ID_MVDV = 243,
		AV_CODEC_ID_MVHA = 244,
		AV_CODEC_ID_CDTOONS = 245,
		AV_CODEC_ID_MV30 = 246,
		AV_CODEC_ID_NOTCHLC = 247,
		AV_CODEC_ID_PFM = 248,
		AV_CODEC_ID_MOBICLIP = 249,
		AV_CODEC_ID_PHOTOCD = 250,
		AV_CODEC_ID_IPU = 251,
		AV_CODEC_ID_ARGO = 252,
		AV_CODEC_ID_CRI = 253,
		AV_CODEC_ID_SIMBIOSIS_IMX = 254,
		AV_CODEC_ID_SGA_VIDEO = 255,
		AV_CODEC_ID_GEM = 256,
		AV_CODEC_ID_VBN = 257,
		AV_CODEC_ID_JPEGXL = 258,
		AV_CODEC_ID_QOI = 259,
		AV_CODEC_ID_PHM = 260,
		AV_CODEC_ID_RADIANCE_HDR = 261,
		AV_CODEC_ID_WBMP = 262,
		AV_CODEC_ID_MEDIA100 = 263,
		AV_CODEC_ID_VQC = 264,
		AV_CODEC_ID_PDV = 265,
		AV_CODEC_ID_EVC = 266,
		AV_CODEC_ID_RTV1 = 267,
		AV_CODEC_ID_VMIX = 268,
		AV_CODEC_ID_LEAD = 269,
		AV_CODEC_ID_DNXUC = 270,
		AV_CODEC_ID_RV60 = 271,
		AV_CODEC_ID_JPEGXL_ANIM = 272,
		AV_CODEC_ID_APV = 273,
		AV_CODEC_ID_PRORES_RAW = 274,
		AV_CODEC_ID_FIRST_AUDIO = 65536,
		AV_CODEC_ID_PCM_S16LE = 65536,
		AV_CODEC_ID_PCM_S16BE = 65537,
		AV_CODEC_ID_PCM_U16LE = 65538,
		AV_CODEC_ID_PCM_U16BE = 65539,
		AV_CODEC_ID_PCM_S8 = 65540,
		AV_CODEC_ID_PCM_U8 = 65541,
		AV_CODEC_ID_PCM_MULAW = 65542,
		AV_CODEC_ID_PCM_ALAW = 65543,
		AV_CODEC_ID_PCM_S32LE = 65544,
		AV_CODEC_ID_PCM_S32BE = 65545,
		AV_CODEC_ID_PCM_U32LE = 65546,
		AV_CODEC_ID_PCM_U32BE = 65547,
		AV_CODEC_ID_PCM_S24LE = 65548,
		AV_CODEC_ID_PCM_S24BE = 65549,
		AV_CODEC_ID_PCM_U24LE = 65550,
		AV_CODEC_ID_PCM_U24BE = 65551,
		AV_CODEC_ID_PCM_S24DAUD = 65552,
		AV_CODEC_ID_PCM_ZORK = 65553,
		AV_CODEC_ID_PCM_S16LE_PLANAR = 65554,
		AV_CODEC_ID_PCM_DVD = 65555,
		AV_CODEC_ID_PCM_F32BE = 65556,
		AV_CODEC_ID_PCM_F32LE = 65557,
		AV_CODEC_ID_PCM_F64BE = 65558,
		AV_CODEC_ID_PCM_F64LE = 65559,
		AV_CODEC_ID_PCM_BLURAY = 65560,
		AV_CODEC_ID_PCM_LXF = 65561,
		AV_CODEC_ID_S302M = 65562,
		AV_CODEC_ID_PCM_S8_PLANAR = 65563,
		AV_CODEC_ID_PCM_S24LE_PLANAR = 65564,
		AV_CODEC_ID_PCM_S32LE_PLANAR = 65565,
		AV_CODEC_ID_PCM_S16BE_PLANAR = 65566,
		AV_CODEC_ID_PCM_S64LE = 65567,
		AV_CODEC_ID_PCM_S64BE = 65568,
		AV_CODEC_ID_PCM_F16LE = 65569,
		AV_CODEC_ID_PCM_F24LE = 65570,
		AV_CODEC_ID_PCM_VIDC = 65571,
		AV_CODEC_ID_PCM_SGA = 65572,
		AV_CODEC_ID_ADPCM_IMA_QT = 69632,
		AV_CODEC_ID_ADPCM_IMA_WAV = 69633,
		AV_CODEC_ID_ADPCM_IMA_DK3 = 69634,
		AV_CODEC_ID_ADPCM_IMA_DK4 = 69635,
		AV_CODEC_ID_ADPCM_IMA_WS = 69636,
		AV_CODEC_ID_ADPCM_IMA_SMJPEG = 69637,
		AV_CODEC_ID_ADPCM_MS = 69638,
		AV_CODEC_ID_ADPCM_4XM = 69639,
		AV_CODEC_ID_ADPCM_XA = 69640,
		AV_CODEC_ID_ADPCM_ADX = 69641,
		AV_CODEC_ID_ADPCM_EA = 69642,
		AV_CODEC_ID_ADPCM_G726 = 69643,
		AV_CODEC_ID_ADPCM_CT = 69644,
		AV_CODEC_ID_ADPCM_SWF = 69645,
		AV_CODEC_ID_ADPCM_YAMAHA = 69646,
		AV_CODEC_ID_ADPCM_SBPRO_4 = 69647,
		AV_CODEC_ID_ADPCM_SBPRO_3 = 69648,
		AV_CODEC_ID_ADPCM_SBPRO_2 = 69649,
		AV_CODEC_ID_ADPCM_THP = 69650,
		AV_CODEC_ID_ADPCM_IMA_AMV = 69651,
		AV_CODEC_ID_ADPCM_EA_R1 = 69652,
		AV_CODEC_ID_ADPCM_EA_R3 = 69653,
		AV_CODEC_ID_ADPCM_EA_R2 = 69654,
		AV_CODEC_ID_ADPCM_IMA_EA_SEAD = 69655,
		AV_CODEC_ID_ADPCM_IMA_EA_EACS = 69656,
		AV_CODEC_ID_ADPCM_EA_XAS = 69657,
		AV_CODEC_ID_ADPCM_EA_MAXIS_XA = 69658,
		AV_CODEC_ID_ADPCM_IMA_ISS = 69659,
		AV_CODEC_ID_ADPCM_G722 = 69660,
		AV_CODEC_ID_ADPCM_IMA_APC = 69661,
		AV_CODEC_ID_ADPCM_VIMA = 69662,
		AV_CODEC_ID_ADPCM_AFC = 69663,
		AV_CODEC_ID_ADPCM_IMA_OKI = 69664,
		AV_CODEC_ID_ADPCM_DTK = 69665,
		AV_CODEC_ID_ADPCM_IMA_RAD = 69666,
		AV_CODEC_ID_ADPCM_G726LE = 69667,
		AV_CODEC_ID_ADPCM_THP_LE = 69668,
		AV_CODEC_ID_ADPCM_PSX = 69669,
		AV_CODEC_ID_ADPCM_AICA = 69670,
		AV_CODEC_ID_ADPCM_IMA_DAT4 = 69671,
		AV_CODEC_ID_ADPCM_MTAF = 69672,
		AV_CODEC_ID_ADPCM_AGM = 69673,
		AV_CODEC_ID_ADPCM_ARGO = 69674,
		AV_CODEC_ID_ADPCM_IMA_SSI = 69675,
		AV_CODEC_ID_ADPCM_ZORK = 69676,
		AV_CODEC_ID_ADPCM_IMA_APM = 69677,
		AV_CODEC_ID_ADPCM_IMA_ALP = 69678,
		AV_CODEC_ID_ADPCM_IMA_MTF = 69679,
		AV_CODEC_ID_ADPCM_IMA_CUNNING = 69680,
		AV_CODEC_ID_ADPCM_IMA_MOFLEX = 69681,
		AV_CODEC_ID_ADPCM_IMA_ACORN = 69682,
		AV_CODEC_ID_ADPCM_XMD = 69683,
		AV_CODEC_ID_ADPCM_IMA_XBOX = 69684,
		AV_CODEC_ID_ADPCM_SANYO = 69685,
		AV_CODEC_ID_AMR_NB = 73728,
		AV_CODEC_ID_AMR_WB = 73729,
		AV_CODEC_ID_RA_144 = 77824,
		AV_CODEC_ID_RA_288 = 77825,
		AV_CODEC_ID_ROQ_DPCM = 81920,
		AV_CODEC_ID_INTERPLAY_DPCM = 81921,
		AV_CODEC_ID_XAN_DPCM = 81922,
		AV_CODEC_ID_SOL_DPCM = 81923,
		AV_CODEC_ID_SDX2_DPCM = 81924,
		AV_CODEC_ID_GREMLIN_DPCM = 81925,
		AV_CODEC_ID_DERF_DPCM = 81926,
		AV_CODEC_ID_WADY_DPCM = 81927,
		AV_CODEC_ID_CBD2_DPCM = 81928,
		AV_CODEC_ID_MP2 = 86016,
		AV_CODEC_ID_MP3 = 86017,
		AV_CODEC_ID_AAC = 86018,
		AV_CODEC_ID_AC3 = 86019,
		AV_CODEC_ID_DTS = 86020,
		AV_CODEC_ID_VORBIS = 86021,
		AV_CODEC_ID_DVAUDIO = 86022,
		AV_CODEC_ID_WMAV1 = 86023,
		AV_CODEC_ID_WMAV2 = 86024,
		AV_CODEC_ID_MACE3 = 86025,
		AV_CODEC_ID_MACE6 = 86026,
		AV_CODEC_ID_VMDAUDIO = 86027,
		AV_CODEC_ID_FLAC = 86028,
		AV_CODEC_ID_MP3ADU = 86029,
		AV_CODEC_ID_MP3ON4 = 86030,
		AV_CODEC_ID_SHORTEN = 86031,
		AV_CODEC_ID_ALAC = 86032,
		AV_CODEC_ID_WESTWOOD_SND1 = 86033,
		AV_CODEC_ID_GSM = 86034,
		AV_CODEC_ID_QDM2 = 86035,
		AV_CODEC_ID_COOK = 86036,
		AV_CODEC_ID_TRUESPEECH = 86037,
		AV_CODEC_ID_TTA = 86038,
		AV_CODEC_ID_SMACKAUDIO = 86039,
		AV_CODEC_ID_QCELP = 86040,
		AV_CODEC_ID_WAVPACK = 86041,
		AV_CODEC_ID_DSICINAUDIO = 86042,
		AV_CODEC_ID_IMC = 86043,
		AV_CODEC_ID_MUSEPACK7 = 86044,
		AV_CODEC_ID_MLP = 86045,
		AV_CODEC_ID_GSM_MS = 86046,
		AV_CODEC_ID_ATRAC3 = 86047,
		AV_CODEC_ID_APE = 86048,
		AV_CODEC_ID_NELLYMOSER = 86049,
		AV_CODEC_ID_MUSEPACK8 = 86050,
		AV_CODEC_ID_SPEEX = 86051,
		AV_CODEC_ID_WMAVOICE = 86052,
		AV_CODEC_ID_WMAPRO = 86053,
		AV_CODEC_ID_WMALOSSLESS = 86054,
		AV_CODEC_ID_ATRAC3P = 86055,
		AV_CODEC_ID_EAC3 = 86056,
		AV_CODEC_ID_SIPR = 86057,
		AV_CODEC_ID_MP1 = 86058,
		AV_CODEC_ID_TWINVQ = 86059,
		AV_CODEC_ID_TRUEHD = 86060,
		AV_CODEC_ID_MP4ALS = 86061,
		AV_CODEC_ID_ATRAC1 = 86062,
		AV_CODEC_ID_BINKAUDIO_RDFT = 86063,
		AV_CODEC_ID_BINKAUDIO_DCT = 86064,
		AV_CODEC_ID_AAC_LATM = 86065,
		AV_CODEC_ID_QDMC = 86066,
		AV_CODEC_ID_CELT = 86067,
		AV_CODEC_ID_G723_1 = 86068,
		AV_CODEC_ID_G729 = 86069,
		AV_CODEC_ID_8SVX_EXP = 86070,
		AV_CODEC_ID_8SVX_FIB = 86071,
		AV_CODEC_ID_BMV_AUDIO = 86072,
		AV_CODEC_ID_RALF = 86073,
		AV_CODEC_ID_IAC = 86074,
		AV_CODEC_ID_ILBC = 86075,
		AV_CODEC_ID_OPUS = 86076,
		AV_CODEC_ID_COMFORT_NOISE = 86077,
		AV_CODEC_ID_TAK = 86078,
		AV_CODEC_ID_METASOUND = 86079,
		AV_CODEC_ID_PAF_AUDIO = 86080,
		AV_CODEC_ID_ON2AVC = 86081,
		AV_CODEC_ID_DSS_SP = 86082,
		AV_CODEC_ID_CODEC2 = 86083,
		AV_CODEC_ID_FFWAVESYNTH = 86084,
		AV_CODEC_ID_SONIC = 86085,
		AV_CODEC_ID_SONIC_LS = 86086,
		AV_CODEC_ID_EVRC = 86087,
		AV_CODEC_ID_SMV = 86088,
		AV_CODEC_ID_DSD_LSBF = 86089,
		AV_CODEC_ID_DSD_MSBF = 86090,
		AV_CODEC_ID_DSD_LSBF_PLANAR = 86091,
		AV_CODEC_ID_DSD_MSBF_PLANAR = 86092,
		AV_CODEC_ID_4GV = 86093,
		AV_CODEC_ID_INTERPLAY_ACM = 86094,
		AV_CODEC_ID_XMA1 = 86095,
		AV_CODEC_ID_XMA2 = 86096,
		AV_CODEC_ID_DST = 86097,
		AV_CODEC_ID_ATRAC3AL = 86098,
		AV_CODEC_ID_ATRAC3PAL = 86099,
		AV_CODEC_ID_DOLBY_E = 86100,
		AV_CODEC_ID_APTX = 86101,
		AV_CODEC_ID_APTX_HD = 86102,
		AV_CODEC_ID_SBC = 86103,
		AV_CODEC_ID_ATRAC9 = 86104,
		AV_CODEC_ID_HCOM = 86105,
		AV_CODEC_ID_ACELP_KELVIN = 86106,
		AV_CODEC_ID_MPEGH_3D_AUDIO = 86107,
		AV_CODEC_ID_SIREN = 86108,
		AV_CODEC_ID_HCA = 86109,
		AV_CODEC_ID_FASTAUDIO = 86110,
		AV_CODEC_ID_MSNSIREN = 86111,
		AV_CODEC_ID_DFPWM = 86112,
		AV_CODEC_ID_BONK = 86113,
		AV_CODEC_ID_MISC4 = 86114,
		AV_CODEC_ID_APAC = 86115,
		AV_CODEC_ID_FTR = 86116,
		AV_CODEC_ID_WAVARC = 86117,
		AV_CODEC_ID_RKA = 86118,
		AV_CODEC_ID_AC4 = 86119,
		AV_CODEC_ID_OSQ = 86120,
		AV_CODEC_ID_QOA = 86121,
		AV_CODEC_ID_LC3 = 86122,
		AV_CODEC_ID_G728 = 86123,
		AV_CODEC_ID_FIRST_SUBTITLE = 94208,
		AV_CODEC_ID_DVD_SUBTITLE = 94208,
		AV_CODEC_ID_DVB_SUBTITLE = 94209,
		AV_CODEC_ID_TEXT = 94210,
		AV_CODEC_ID_XSUB = 94211,
		AV_CODEC_ID_SSA = 94212,
		AV_CODEC_ID_MOV_TEXT = 94213,
		AV_CODEC_ID_HDMV_PGS_SUBTITLE = 94214,
		AV_CODEC_ID_DVB_TELETEXT = 94215,
		AV_CODEC_ID_SRT = 94216,
		AV_CODEC_ID_MICRODVD = 94217,
		AV_CODEC_ID_EIA_608 = 94218,
		AV_CODEC_ID_JACOSUB = 94219,
		AV_CODEC_ID_SAMI = 94220,
		AV_CODEC_ID_REALTEXT = 94221,
		AV_CODEC_ID_STL = 94222,
		AV_CODEC_ID_SUBVIEWER1 = 94223,
		AV_CODEC_ID_SUBVIEWER = 94224,
		AV_CODEC_ID_SUBRIP = 94225,
		AV_CODEC_ID_WEBVTT = 94226,
		AV_CODEC_ID_MPL2 = 94227,
		AV_CODEC_ID_VPLAYER = 94228,
		AV_CODEC_ID_PJS = 94229,
		AV_CODEC_ID_ASS = 94230,
		AV_CODEC_ID_HDMV_TEXT_SUBTITLE = 94231,
		AV_CODEC_ID_TTML = 94232,
		AV_CODEC_ID_ARIB_CAPTION = 94233,
		AV_CODEC_ID_IVTV_VBI = 94234,
		AV_CODEC_ID_FIRST_UNKNOWN = 98304,
		AV_CODEC_ID_TTF = 98304,
		AV_CODEC_ID_SCTE_35 = 98305,
		AV_CODEC_ID_EPG = 98306,
		AV_CODEC_ID_BINTEXT = 98307,
		AV_CODEC_ID_XBIN = 98308,
		AV_CODEC_ID_IDF = 98309,
		AV_CODEC_ID_OTF = 98310,
		AV_CODEC_ID_SMPTE_KLV = 98311,
		AV_CODEC_ID_DVD_NAV = 98312,
		AV_CODEC_ID_TIMED_ID3 = 98313,
		AV_CODEC_ID_BIN_DATA = 98314,
		AV_CODEC_ID_SMPTE_2038 = 98315,
		AV_CODEC_ID_LCEVC = 98316,
		AV_CODEC_ID_SMPTE_436M_ANC = 98317,
		AV_CODEC_ID_PROBE = 102400,
		AV_CODEC_ID_MPEG2TS = 131072,
		AV_CODEC_ID_MPEG4SYSTEMS = 131073,
		AV_CODEC_ID_FFMETADATA = 135168,
		AV_CODEC_ID_WRAPPED_AVFRAME = 135169,
		AV_CODEC_ID_VNULL = 135170,
		AV_CODEC_ID_ANULL = 135171
	}
	public enum AVColorPrimaries
	{
		AVCOL_PRI_RESERVED0 = 0,
		AVCOL_PRI_BT709 = 1,
		AVCOL_PRI_UNSPECIFIED = 2,
		AVCOL_PRI_RESERVED = 3,
		AVCOL_PRI_BT470M = 4,
		AVCOL_PRI_BT470BG = 5,
		AVCOL_PRI_SMPTE170M = 6,
		AVCOL_PRI_SMPTE240M = 7,
		AVCOL_PRI_FILM = 8,
		AVCOL_PRI_BT2020 = 9,
		AVCOL_PRI_SMPTE428 = 10,
		AVCOL_PRI_SMPTEST428_1 = 10,
		AVCOL_PRI_SMPTE431 = 11,
		AVCOL_PRI_SMPTE432 = 12,
		AVCOL_PRI_EBU3213 = 22,
		AVCOL_PRI_JEDEC_P22 = 22,
		AVCOL_PRI_NB = 23
	}
	public enum AVColorRange
	{
		AVCOL_RANGE_UNSPECIFIED,
		AVCOL_RANGE_MPEG,
		AVCOL_RANGE_JPEG,
		AVCOL_RANGE_NB
	}
	public enum AVColorSpace
	{
		AVCOL_SPC_RGB = 0,
		AVCOL_SPC_BT709 = 1,
		AVCOL_SPC_UNSPECIFIED = 2,
		AVCOL_SPC_RESERVED = 3,
		AVCOL_SPC_FCC = 4,
		AVCOL_SPC_BT470BG = 5,
		AVCOL_SPC_SMPTE170M = 6,
		AVCOL_SPC_SMPTE240M = 7,
		AVCOL_SPC_YCGCO = 8,
		AVCOL_SPC_YCOCG = 8,
		AVCOL_SPC_BT2020_NCL = 9,
		AVCOL_SPC_BT2020_CL = 10,
		AVCOL_SPC_SMPTE2085 = 11,
		AVCOL_SPC_CHROMA_DERIVED_NCL = 12,
		AVCOL_SPC_CHROMA_DERIVED_CL = 13,
		AVCOL_SPC_ICTCP = 14,
		AVCOL_SPC_IPT_C2 = 15,
		AVCOL_SPC_YCGCO_RE = 16,
		AVCOL_SPC_YCGCO_RO = 17,
		AVCOL_SPC_NB = 18
	}
	public enum AVColorTransferCharacteristic
	{
		AVCOL_TRC_RESERVED0 = 0,
		AVCOL_TRC_BT709 = 1,
		AVCOL_TRC_UNSPECIFIED = 2,
		AVCOL_TRC_RESERVED = 3,
		AVCOL_TRC_GAMMA22 = 4,
		AVCOL_TRC_GAMMA28 = 5,
		AVCOL_TRC_SMPTE170M = 6,
		AVCOL_TRC_SMPTE240M = 7,
		AVCOL_TRC_LINEAR = 8,
		AVCOL_TRC_LOG = 9,
		AVCOL_TRC_LOG_SQRT = 10,
		AVCOL_TRC_IEC61966_2_4 = 11,
		AVCOL_TRC_BT1361_ECG = 12,
		AVCOL_TRC_IEC61966_2_1 = 13,
		AVCOL_TRC_BT2020_10 = 14,
		AVCOL_TRC_BT2020_12 = 15,
		AVCOL_TRC_SMPTE2084 = 16,
		AVCOL_TRC_SMPTEST2084 = 16,
		AVCOL_TRC_SMPTE428 = 17,
		AVCOL_TRC_SMPTEST428_1 = 17,
		AVCOL_TRC_ARIB_STD_B67 = 18,
		AVCOL_TRC_NB = 19
	}
	public enum AVDevToAppMessageType
	{
		AV_DEV_TO_APP_NONE = 1313820229,
		AV_DEV_TO_APP_CREATE_WINDOW_BUFFER = 1111708229,
		AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER = 1112560197,
		AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER = 1111771475,
		AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER = 1111770451,
		AV_DEV_TO_APP_BUFFER_OVERFLOW = 1112491596,
		AV_DEV_TO_APP_BUFFER_UNDERFLOW = 1112884812,
		AV_DEV_TO_APP_BUFFER_READABLE = 1112687648,
		AV_DEV_TO_APP_BUFFER_WRITABLE = 1113018912,
		AV_DEV_TO_APP_MUTE_STATE_CHANGED = 1129141588,
		AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED = 1129729868
	}
	public enum AVDiscard
	{
		AVDISCARD_NONE = -16,
		AVDISCARD_DEFAULT = 0,
		AVDISCARD_NONREF = 8,
		AVDISCARD_BIDIR = 16,
		AVDISCARD_NONINTRA = 24,
		AVDISCARD_NONKEY = 32,
		AVDISCARD_ALL = 48
	}
	public enum AVDurationEstimationMethod
	{
		AVFMT_DURATION_FROM_PTS,
		AVFMT_DURATION_FROM_STREAM,
		AVFMT_DURATION_FROM_BITRATE
	}
	public enum AVFieldOrder
	{
		AV_FIELD_UNKNOWN,
		AV_FIELD_PROGRESSIVE,
		AV_FIELD_TT,
		AV_FIELD_BB,
		AV_FIELD_TB,
		AV_FIELD_BT
	}
	public enum AVFrameSideDataType
	{
		AV_FRAME_DATA_PANSCAN,
		AV_FRAME_DATA_A53_CC,
		AV_FRAME_DATA_STEREO3D,
		AV_FRAME_DATA_MATRIXENCODING,
		AV_FRAME_DATA_DOWNMIX_INFO,
		AV_FRAME_DATA_REPLAYGAIN,
		AV_FRAME_DATA_DISPLAYMATRIX,
		AV_FRAME_DATA_AFD,
		AV_FRAME_DATA_MOTION_VECTORS,
		AV_FRAME_DATA_SKIP_SAMPLES,
		AV_FRAME_DATA_AUDIO_SERVICE_TYPE,
		AV_FRAME_DATA_MASTERING_DISPLAY_METADATA,
		AV_FRAME_DATA_GOP_TIMECODE,
		AV_FRAME_DATA_SPHERICAL,
		AV_FRAME_DATA_CONTENT_LIGHT_LEVEL,
		AV_FRAME_DATA_ICC_PROFILE,
		AV_FRAME_DATA_S12M_TIMECODE,
		AV_FRAME_DATA_DYNAMIC_HDR_PLUS,
		AV_FRAME_DATA_REGIONS_OF_INTEREST,
		AV_FRAME_DATA_VIDEO_ENC_PARAMS,
		AV_FRAME_DATA_SEI_UNREGISTERED,
		AV_FRAME_DATA_FILM_GRAIN_PARAMS,
		AV_FRAME_DATA_DETECTION_BBOXES,
		AV_FRAME_DATA_DOVI_RPU_BUFFER,
		AV_FRAME_DATA_DOVI_METADATA,
		AV_FRAME_DATA_DYNAMIC_HDR_VIVID,
		AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT,
		AV_FRAME_DATA_VIDEO_HINT,
		AV_FRAME_DATA_LCEVC,
		AV_FRAME_DATA_VIEW_ID,
		AV_FRAME_DATA_3D_REFERENCE_DISPLAYS
	}
	public enum AVHDRPlusOverlapProcessOption
	{
		AV_HDR_PLUS_OVERLAP_PROCESS_WEIGHTED_AVERAGING,
		AV_HDR_PLUS_OVERLAP_PROCESS_LAYERING
	}
	public enum AVHWDeviceType
	{
		AV_HWDEVICE_TYPE_NONE,
		AV_HWDEVICE_TYPE_VDPAU,
		AV_HWDEVICE_TYPE_CUDA,
		AV_HWDEVICE_TYPE_VAAPI,
		AV_HWDEVICE_TYPE_DXVA2,
		AV_HWDEVICE_TYPE_QSV,
		AV_HWDEVICE_TYPE_VIDEOTOOLBOX,
		AV_HWDEVICE_TYPE_D3D11VA,
		AV_HWDEVICE_TYPE_DRM,
		AV_HWDEVICE_TYPE_OPENCL,
		AV_HWDEVICE_TYPE_MEDIACODEC,
		AV_HWDEVICE_TYPE_VULKAN,
		AV_HWDEVICE_TYPE_D3D12VA,
		AV_HWDEVICE_TYPE_AMF,
		AV_HWDEVICE_TYPE_OHCODEC
	}
	public enum AVHWFrameTransferDirection
	{
		AV_HWFRAME_TRANSFER_DIRECTION_FROM,
		AV_HWFRAME_TRANSFER_DIRECTION_TO
	}
	public enum AVIODataMarkerType
	{
		AVIO_DATA_MARKER_HEADER,
		AVIO_DATA_MARKER_SYNC_POINT,
		AVIO_DATA_MARKER_BOUNDARY_POINT,
		AVIO_DATA_MARKER_UNKNOWN,
		AVIO_DATA_MARKER_TRAILER,
		AVIO_DATA_MARKER_FLUSH_POINT
	}
	public enum AVIODirEntryType
	{
		AVIO_ENTRY_UNKNOWN,
		AVIO_ENTRY_BLOCK_DEVICE,
		AVIO_ENTRY_CHARACTER_DEVICE,
		AVIO_ENTRY_DIRECTORY,
		AVIO_ENTRY_NAMED_PIPE,
		AVIO_ENTRY_SYMBOLIC_LINK,
		AVIO_ENTRY_SOCKET,
		AVIO_ENTRY_FILE,
		AVIO_ENTRY_SERVER,
		AVIO_ENTRY_SHARE,
		AVIO_ENTRY_WORKGROUP
	}
	public enum AVMatrixEncoding
	{
		AV_MATRIX_ENCODING_NONE,
		AV_MATRIX_ENCODING_DOLBY,
		AV_MATRIX_ENCODING_DPLII,
		AV_MATRIX_ENCODING_DPLIIX,
		AV_MATRIX_ENCODING_DPLIIZ,
		AV_MATRIX_ENCODING_DOLBYEX,
		AV_MATRIX_ENCODING_DOLBYHEADPHONE,
		AV_MATRIX_ENCODING_NB
	}
	public enum AVMediaType
	{
		AVMEDIA_TYPE_UNKNOWN = -1,
		AVMEDIA_TYPE_VIDEO,
		AVMEDIA_TYPE_AUDIO,
		AVMEDIA_TYPE_DATA,
		AVMEDIA_TYPE_SUBTITLE,
		AVMEDIA_TYPE_ATTACHMENT,
		AVMEDIA_TYPE_NB
	}
	public enum AVOptionType
	{
		AV_OPT_TYPE_FLAGS = 1,
		AV_OPT_TYPE_INT = 2,
		AV_OPT_TYPE_INT64 = 3,
		AV_OPT_TYPE_DOUBLE = 4,
		AV_OPT_TYPE_FLOAT = 5,
		AV_OPT_TYPE_STRING = 6,
		AV_OPT_TYPE_RATIONAL = 7,
		AV_OPT_TYPE_BINARY = 8,
		AV_OPT_TYPE_DICT = 9,
		AV_OPT_TYPE_UINT64 = 10,
		AV_OPT_TYPE_CONST = 11,
		AV_OPT_TYPE_IMAGE_SIZE = 12,
		AV_OPT_TYPE_PIXEL_FMT = 13,
		AV_OPT_TYPE_SAMPLE_FMT = 14,
		AV_OPT_TYPE_VIDEO_RATE = 15,
		AV_OPT_TYPE_DURATION = 16,
		AV_OPT_TYPE_COLOR = 17,
		AV_OPT_TYPE_BOOL = 18,
		AV_OPT_TYPE_CHLAYOUT = 19,
		AV_OPT_TYPE_UINT = 20,
		AV_OPT_TYPE_FLAG_ARRAY = 65536
	}
	public enum AVPacketSideDataType
	{
		AV_PKT_DATA_PALETTE,
		AV_PKT_DATA_NEW_EXTRADATA,
		AV_PKT_DATA_PARAM_CHANGE,
		AV_PKT_DATA_H263_MB_INFO,
		AV_PKT_DATA_REPLAYGAIN,
		AV_PKT_DATA_DISPLAYMATRIX,
		AV_PKT_DATA_STEREO3D,
		AV_PKT_DATA_AUDIO_SERVICE_TYPE,
		AV_PKT_DATA_QUALITY_STATS,
		AV_PKT_DATA_FALLBACK_TRACK,
		AV_PKT_DATA_CPB_PROPERTIES,
		AV_PKT_DATA_SKIP_SAMPLES,
		AV_PKT_DATA_JP_DUALMONO,
		AV_PKT_DATA_STRINGS_METADATA,
		AV_PKT_DATA_SUBTITLE_POSITION,
		AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
		AV_PKT_DATA_WEBVTT_IDENTIFIER,
		AV_PKT_DATA_WEBVTT_SETTINGS,
		AV_PKT_DATA_METADATA_UPDATE,
		AV_PKT_DATA_MPEGTS_STREAM_ID,
		AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
		AV_PKT_DATA_SPHERICAL,
		AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
		AV_PKT_DATA_A53_CC,
		AV_PKT_DATA_ENCRYPTION_INIT_INFO,
		AV_PKT_DATA_ENCRYPTION_INFO,
		AV_PKT_DATA_AFD,
		AV_PKT_DATA_PRFT,
		AV_PKT_DATA_ICC_PROFILE,
		AV_PKT_DATA_DOVI_CONF,
		AV_PKT_DATA_S12M_TIMECODE,
		AV_PKT_DATA_DYNAMIC_HDR10_PLUS,
		AV_PKT_DATA_IAMF_MIX_GAIN_PARAM,
		AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM,
		AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM,
		AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,
		AV_PKT_DATA_FRAME_CROPPING,
		AV_PKT_DATA_LCEVC,
		AV_PKT_DATA_3D_REFERENCE_DISPLAYS,
		AV_PKT_DATA_RTCP_SR,
		AV_PKT_DATA_NB
	}
	public enum AVPictureStructure
	{
		AV_PICTURE_STRUCTURE_UNKNOWN,
		AV_PICTURE_STRUCTURE_TOP_FIELD,
		AV_PICTURE_STRUCTURE_BOTTOM_FIELD,
		AV_PICTURE_STRUCTURE_FRAME
	}
	public enum AVPictureType
	{
		AV_PICTURE_TYPE_NONE,
		AV_PICTURE_TYPE_I,
		AV_PICTURE_TYPE_P,
		AV_PICTURE_TYPE_B,
		AV_PICTURE_TYPE_S,
		AV_PICTURE_TYPE_SI,
		AV_PICTURE_TYPE_SP,
		AV_PICTURE_TYPE_BI
	}
	public enum AVPixelFormat
	{
		AV_PIX_FMT_NONE = -1,
		AV_PIX_FMT_YUV420P = 0,
		AV_PIX_FMT_YUYV422 = 1,
		AV_PIX_FMT_RGB24 = 2,
		AV_PIX_FMT_BGR24 = 3,
		AV_PIX_FMT_YUV422P = 4,
		AV_PIX_FMT_YUV444P = 5,
		AV_PIX_FMT_YUV410P = 6,
		AV_PIX_FMT_YUV411P = 7,
		AV_PIX_FMT_GRAY8 = 8,
		AV_PIX_FMT_MONOWHITE = 9,
		AV_PIX_FMT_MONOBLACK = 10,
		AV_PIX_FMT_PAL8 = 11,
		AV_PIX_FMT_YUVJ420P = 12,
		AV_PIX_FMT_YUVJ422P = 13,
		AV_PIX_FMT_YUVJ444P = 14,
		AV_PIX_FMT_UYVY422 = 15,
		AV_PIX_FMT_UYYVYY411 = 16,
		AV_PIX_FMT_BGR8 = 17,
		AV_PIX_FMT_BGR4 = 18,
		AV_PIX_FMT_BGR4_BYTE = 19,
		AV_PIX_FMT_RGB8 = 20,
		AV_PIX_FMT_RGB4 = 21,
		AV_PIX_FMT_RGB4_BYTE = 22,
		AV_PIX_FMT_NV12 = 23,
		AV_PIX_FMT_NV21 = 24,
		AV_PIX_FMT_ARGB = 25,
		AV_PIX_FMT_RGBA = 26,
		AV_PIX_FMT_ABGR = 27,
		AV_PIX_FMT_BGRA = 28,
		AV_PIX_FMT_GRAY16BE = 29,
		AV_PIX_FMT_GRAY16LE = 30,
		AV_PIX_FMT_YUV440P = 31,
		AV_PIX_FMT_YUVJ440P = 32,
		AV_PIX_FMT_YUVA420P = 33,
		AV_PIX_FMT_RGB48BE = 34,
		AV_PIX_FMT_RGB48LE = 35,
		AV_PIX_FMT_RGB565BE = 36,
		AV_PIX_FMT_RGB565LE = 37,
		AV_PIX_FMT_RGB555BE = 38,
		AV_PIX_FMT_RGB555LE = 39,
		AV_PIX_FMT_BGR565BE = 40,
		AV_PIX_FMT_BGR565LE = 41,
		AV_PIX_FMT_BGR555BE = 42,
		AV_PIX_FMT_BGR555LE = 43,
		AV_PIX_FMT_VAAPI = 44,
		AV_PIX_FMT_YUV420P16LE = 45,
		AV_PIX_FMT_YUV420P16BE = 46,
		AV_PIX_FMT_YUV422P16LE = 47,
		AV_PIX_FMT_YUV422P16BE = 48,
		AV_PIX_FMT_YUV444P16LE = 49,
		AV_PIX_FMT_YUV444P16BE = 50,
		AV_PIX_FMT_DXVA2_VLD = 51,
		AV_PIX_FMT_RGB444LE = 52,
		AV_PIX_FMT_RGB444BE = 53,
		AV_PIX_FMT_BGR444LE = 54,
		AV_PIX_FMT_BGR444BE = 55,
		AV_PIX_FMT_YA8 = 56,
		AV_PIX_FMT_Y400A = 56,
		AV_PIX_FMT_GRAY8A = 56,
		AV_PIX_FMT_BGR48BE = 57,
		AV_PIX_FMT_BGR48LE = 58,
		AV_PIX_FMT_YUV420P9BE = 59,
		AV_PIX_FMT_YUV420P9LE = 60,
		AV_PIX_FMT_YUV420P10BE = 61,
		AV_PIX_FMT_YUV420P10LE = 62,
		AV_PIX_FMT_YUV422P10BE = 63,
		AV_PIX_FMT_YUV422P10LE = 64,
		AV_PIX_FMT_YUV444P9BE = 65,
		AV_PIX_FMT_YUV444P9LE = 66,
		AV_PIX_FMT_YUV444P10BE = 67,
		AV_PIX_FMT_YUV444P10LE = 68,
		AV_PIX_FMT_YUV422P9BE = 69,
		AV_PIX_FMT_YUV422P9LE = 70,
		AV_PIX_FMT_GBRP = 71,
		AV_PIX_FMT_GBR24P = 71,
		AV_PIX_FMT_GBRP9BE = 72,
		AV_PIX_FMT_GBRP9LE = 73,
		AV_PIX_FMT_GBRP10BE = 74,
		AV_PIX_FMT_GBRP10LE = 75,
		AV_PIX_FMT_GBRP16BE = 76,
		AV_PIX_FMT_GBRP16LE = 77,
		AV_PIX_FMT_YUVA422P = 78,
		AV_PIX_FMT_YUVA444P = 79,
		AV_PIX_FMT_YUVA420P9BE = 80,
		AV_PIX_FMT_YUVA420P9LE = 81,
		AV_PIX_FMT_YUVA422P9BE = 82,
		AV_PIX_FMT_YUVA422P9LE = 83,
		AV_PIX_FMT_YUVA444P9BE = 84,
		AV_PIX_FMT_YUVA444P9LE = 85,
		AV_PIX_FMT_YUVA420P10BE = 86,
		AV_PIX_FMT_YUVA420P10LE = 87,
		AV_PIX_FMT_YUVA422P10BE = 88,
		AV_PIX_FMT_YUVA422P10LE = 89,
		AV_PIX_FMT_YUVA444P10BE = 90,
		AV_PIX_FMT_YUVA444P10LE = 91,
		AV_PIX_FMT_YUVA420P16BE = 92,
		AV_PIX_FMT_YUVA420P16LE = 93,
		AV_PIX_FMT_YUVA422P16BE = 94,
		AV_PIX_FMT_YUVA422P16LE = 95,
		AV_PIX_FMT_YUVA444P16BE = 96,
		AV_PIX_FMT_YUVA444P16LE = 97,
		AV_PIX_FMT_VDPAU = 98,
		AV_PIX_FMT_XYZ12LE = 99,
		AV_PIX_FMT_XYZ12BE = 100,
		AV_PIX_FMT_NV16 = 101,
		AV_PIX_FMT_NV20LE = 102,
		AV_PIX_FMT_NV20BE = 103,
		AV_PIX_FMT_RGBA64BE = 104,
		AV_PIX_FMT_RGBA64LE = 105,
		AV_PIX_FMT_BGRA64BE = 106,
		AV_PIX_FMT_BGRA64LE = 107,
		AV_PIX_FMT_YVYU422 = 108,
		AV_PIX_FMT_YA16BE = 109,
		AV_PIX_FMT_YA16LE = 110,
		AV_PIX_FMT_GBRAP = 111,
		AV_PIX_FMT_GBRAP16BE = 112,
		AV_PIX_FMT_GBRAP16LE = 113,
		AV_PIX_FMT_QSV = 114,
		AV_PIX_FMT_MMAL = 115,
		AV_PIX_FMT_D3D11VA_VLD = 116,
		AV_PIX_FMT_CUDA = 117,
		AV_PIX_FMT_0RGB = 118,
		AV_PIX_FMT_RGB0 = 119,
		AV_PIX_FMT_0BGR = 120,
		AV_PIX_FMT_BGR0 = 121,
		AV_PIX_FMT_YUV420P12BE = 122,
		AV_PIX_FMT_YUV420P12LE = 123,
		AV_PIX_FMT_YUV420P14BE = 124,
		AV_PIX_FMT_YUV420P14LE = 125,
		AV_PIX_FMT_YUV422P12BE = 126,
		AV_PIX_FMT_YUV422P12LE = 127,
		AV_PIX_FMT_YUV422P14BE = 128,
		AV_PIX_FMT_YUV422P14LE = 129,
		AV_PIX_FMT_YUV444P12BE = 130,
		AV_PIX_FMT_YUV444P12LE = 131,
		AV_PIX_FMT_YUV444P14BE = 132,
		AV_PIX_FMT_YUV444P14LE = 133,
		AV_PIX_FMT_GBRP12BE = 134,
		AV_PIX_FMT_GBRP12LE = 135,
		AV_PIX_FMT_GBRP14BE = 136,
		AV_PIX_FMT_GBRP14LE = 137,
		AV_PIX_FMT_YUVJ411P = 138,
		AV_PIX_FMT_BAYER_BGGR8 = 139,
		AV_PIX_FMT_BAYER_RGGB8 = 140,
		AV_PIX_FMT_BAYER_GBRG8 = 141,
		AV_PIX_FMT_BAYER_GRBG8 = 142,
		AV_PIX_FMT_BAYER_BGGR16LE = 143,
		AV_PIX_FMT_BAYER_BGGR16BE = 144,
		AV_PIX_FMT_BAYER_RGGB16LE = 145,
		AV_PIX_FMT_BAYER_RGGB16BE = 146,
		AV_PIX_FMT_BAYER_GBRG16LE = 147,
		AV_PIX_FMT_BAYER_GBRG16BE = 148,
		AV_PIX_FMT_BAYER_GRBG16LE = 149,
		AV_PIX_FMT_BAYER_GRBG16BE = 150,
		AV_PIX_FMT_YUV440P10LE = 151,
		AV_PIX_FMT_YUV440P10BE = 152,
		AV_PIX_FMT_YUV440P12LE = 153,
		AV_PIX_FMT_YUV440P12BE = 154,
		AV_PIX_FMT_AYUV64LE = 155,
		AV_PIX_FMT_AYUV64BE = 156,
		AV_PIX_FMT_VIDEOTOOLBOX = 157,
		AV_PIX_FMT_P010LE = 158,
		AV_PIX_FMT_P010BE = 159,
		AV_PIX_FMT_GBRAP12BE = 160,
		AV_PIX_FMT_GBRAP12LE = 161,
		AV_PIX_FMT_GBRAP10BE = 162,
		AV_PIX_FMT_GBRAP10LE = 163,
		AV_PIX_FMT_MEDIACODEC = 164,
		AV_PIX_FMT_GRAY12BE = 165,
		AV_PIX_FMT_GRAY12LE = 166,
		AV_PIX_FMT_GRAY10BE = 167,
		AV_PIX_FMT_GRAY10LE = 168,
		AV_PIX_FMT_P016LE = 169,
		AV_PIX_FMT_P016BE = 170,
		AV_PIX_FMT_D3D11 = 171,
		AV_PIX_FMT_GRAY9BE = 172,
		AV_PIX_FMT_GRAY9LE = 173,
		AV_PIX_FMT_GBRPF32BE = 174,
		AV_PIX_FMT_GBRPF32LE = 175,
		AV_PIX_FMT_GBRAPF32BE = 176,
		AV_PIX_FMT_GBRAPF32LE = 177,
		AV_PIX_FMT_DRM_PRIME = 178,
		AV_PIX_FMT_OPENCL = 179,
		AV_PIX_FMT_GRAY14BE = 180,
		AV_PIX_FMT_GRAY14LE = 181,
		AV_PIX_FMT_GRAYF32BE = 182,
		AV_PIX_FMT_GRAYF32LE = 183,
		AV_PIX_FMT_YUVA422P12BE = 184,
		AV_PIX_FMT_YUVA422P12LE = 185,
		AV_PIX_FMT_YUVA444P12BE = 186,
		AV_PIX_FMT_YUVA444P12LE = 187,
		AV_PIX_FMT_NV24 = 188,
		AV_PIX_FMT_NV42 = 189,
		AV_PIX_FMT_VULKAN = 190,
		AV_PIX_FMT_Y210BE = 191,
		AV_PIX_FMT_Y210LE = 192,
		AV_PIX_FMT_X2RGB10LE = 193,
		AV_PIX_FMT_X2RGB10BE = 194,
		AV_PIX_FMT_X2BGR10LE = 195,
		AV_PIX_FMT_X2BGR10BE = 196,
		AV_PIX_FMT_P210BE = 197,
		AV_PIX_FMT_P210LE = 198,
		AV_PIX_FMT_P410BE = 199,
		AV_PIX_FMT_P410LE = 200,
		AV_PIX_FMT_P216BE = 201,
		AV_PIX_FMT_P216LE = 202,
		AV_PIX_FMT_P416BE = 203,
		AV_PIX_FMT_P416LE = 204,
		AV_PIX_FMT_VUYA = 205,
		AV_PIX_FMT_RGBAF16BE = 206,
		AV_PIX_FMT_RGBAF16LE = 207,
		AV_PIX_FMT_VUYX = 208,
		AV_PIX_FMT_P012LE = 209,
		AV_PIX_FMT_P012BE = 210,
		AV_PIX_FMT_Y212BE = 211,
		AV_PIX_FMT_Y212LE = 212,
		AV_PIX_FMT_XV30BE = 213,
		AV_PIX_FMT_XV30LE = 214,
		AV_PIX_FMT_XV36BE = 215,
		AV_PIX_FMT_XV36LE = 216,
		AV_PIX_FMT_RGBF32BE = 217,
		AV_PIX_FMT_RGBF32LE = 218,
		AV_PIX_FMT_RGBAF32BE = 219,
		AV_PIX_FMT_RGBAF32LE = 220,
		AV_PIX_FMT_P212BE = 221,
		AV_PIX_FMT_P212LE = 222,
		AV_PIX_FMT_P412BE = 223,
		AV_PIX_FMT_P412LE = 224,
		AV_PIX_FMT_GBRAP14BE = 225,
		AV_PIX_FMT_GBRAP14LE = 226,
		AV_PIX_FMT_D3D12 = 227,
		AV_PIX_FMT_AYUV = 228,
		AV_PIX_FMT_UYVA = 229,
		AV_PIX_FMT_VYU444 = 230,
		AV_PIX_FMT_V30XBE = 231,
		AV_PIX_FMT_V30XLE = 232,
		AV_PIX_FMT_RGBF16BE = 233,
		AV_PIX_FMT_RGBF16LE = 234,
		AV_PIX_FMT_RGBA128BE = 235,
		AV_PIX_FMT_RGBA128LE = 236,
		AV_PIX_FMT_RGB96BE = 237,
		AV_PIX_FMT_RGB96LE = 238,
		AV_PIX_FMT_Y216BE = 239,
		AV_PIX_FMT_Y216LE = 240,
		AV_PIX_FMT_XV48BE = 241,
		AV_PIX_FMT_XV48LE = 242,
		AV_PIX_FMT_GBRPF16BE = 243,
		AV_PIX_FMT_GBRPF16LE = 244,
		AV_PIX_FMT_GBRAPF16BE = 245,
		AV_PIX_FMT_GBRAPF16LE = 246,
		AV_PIX_FMT_GRAYF16BE = 247,
		AV_PIX_FMT_GRAYF16LE = 248,
		AV_PIX_FMT_AMF_SURFACE = 249,
		AV_PIX_FMT_GRAY32BE = 250,
		AV_PIX_FMT_GRAY32LE = 251,
		AV_PIX_FMT_YAF32BE = 252,
		AV_PIX_FMT_YAF32LE = 253,
		AV_PIX_FMT_YAF16BE = 254,
		AV_PIX_FMT_YAF16LE = 255,
		AV_PIX_FMT_GBRAP32BE = 256,
		AV_PIX_FMT_GBRAP32LE = 257,
		AV_PIX_FMT_YUV444P10MSBBE = 258,
		AV_PIX_FMT_YUV444P10MSBLE = 259,
		AV_PIX_FMT_YUV444P12MSBBE = 260,
		AV_PIX_FMT_YUV444P12MSBLE = 261,
		AV_PIX_FMT_GBRP10MSBBE = 262,
		AV_PIX_FMT_GBRP10MSBLE = 263,
		AV_PIX_FMT_GBRP12MSBBE = 264,
		AV_PIX_FMT_GBRP12MSBLE = 265,
		AV_PIX_FMT_OHCODEC = 266,
		AV_PIX_FMT_NB = 267
	}
	public enum AVRounding
	{
		AV_ROUND_ZERO = 0,
		AV_ROUND_INF = 1,
		AV_ROUND_DOWN = 2,
		AV_ROUND_UP = 3,
		AV_ROUND_NEAR_INF = 5,
		AV_ROUND_PASS_MINMAX = 8192
	}
	public enum AVSampleFormat
	{
		AV_SAMPLE_FMT_NONE = -1,
		AV_SAMPLE_FMT_U8,
		AV_SAMPLE_FMT_S16,
		AV_SAMPLE_FMT_S32,
		AV_SAMPLE_FMT_FLT,
		AV_SAMPLE_FMT_DBL,
		AV_SAMPLE_FMT_U8P,
		AV_SAMPLE_FMT_S16P,
		AV_SAMPLE_FMT_S32P,
		AV_SAMPLE_FMT_FLTP,
		AV_SAMPLE_FMT_DBLP,
		AV_SAMPLE_FMT_S64,
		AV_SAMPLE_FMT_S64P,
		AV_SAMPLE_FMT_NB
	}
	public enum AVSideDataParamChangeFlags
	{
		AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 4,
		AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 8
	}
	public enum AVSideDataProps
	{
		AV_SIDE_DATA_PROP_GLOBAL = 1,
		AV_SIDE_DATA_PROP_MULTI = 2,
		AV_SIDE_DATA_PROP_SIZE_DEPENDENT = 4,
		AV_SIDE_DATA_PROP_COLOR_DEPENDENT = 8,
		AV_SIDE_DATA_PROP_CHANNEL_DEPENDENT = 0x10
	}
	public enum AVStreamGroupParamsType
	{
		AV_STREAM_GROUP_PARAMS_NONE,
		AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT,
		AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION,
		AV_STREAM_GROUP_PARAMS_TILE_GRID,
		AV_STREAM_GROUP_PARAMS_LCEVC
	}
	public enum AVStreamParseType
	{
		AVSTREAM_PARSE_NONE,
		AVSTREAM_PARSE_FULL,
		AVSTREAM_PARSE_HEADERS,
		AVSTREAM_PARSE_TIMESTAMPS,
		AVSTREAM_PARSE_FULL_ONCE,
		AVSTREAM_PARSE_FULL_RAW
	}
	public enum AVSubtitleType
	{
		SUBTITLE_NONE,
		SUBTITLE_BITMAP,
		SUBTITLE_TEXT,
		SUBTITLE_ASS
	}
	public enum AVTimebaseSource
	{
		AVFMT_TBCF_AUTO = -1,
		AVFMT_TBCF_DECODER,
		AVFMT_TBCF_DEMUXER,
		AVFMT_TBCF_R_FRAMERATE
	}
	public enum AVTimecodeFlag
	{
		AV_TIMECODE_FLAG_DROPFRAME = 1,
		AV_TIMECODE_FLAG_24HOURSMAX = 2,
		AV_TIMECODE_FLAG_ALLOWNEGATIVE = 4
	}
	public enum SwrDitherType
	{
		SWR_DITHER_NONE = 0,
		SWR_DITHER_RECTANGULAR = 1,
		SWR_DITHER_TRIANGULAR = 2,
		SWR_DITHER_TRIANGULAR_HIGHPASS = 3,
		SWR_DITHER_NS = 64,
		SWR_DITHER_NS_LIPSHITZ = 65,
		SWR_DITHER_NS_F_WEIGHTED = 66,
		SWR_DITHER_NS_MODIFIED_E_WEIGHTED = 67,
		SWR_DITHER_NS_IMPROVED_E_WEIGHTED = 68,
		SWR_DITHER_NS_SHIBATA = 69,
		SWR_DITHER_NS_LOW_SHIBATA = 70,
		SWR_DITHER_NS_HIGH_SHIBATA = 71,
		SWR_DITHER_NB = 72
	}
	public enum SwrEngine
	{
		SWR_ENGINE_SWR,
		SWR_ENGINE_SOXR,
		SWR_ENGINE_NB
	}
	public enum SwrFilterType
	{
		SWR_FILTER_TYPE_CUBIC,
		SWR_FILTER_TYPE_BLACKMAN_NUTTALL,
		SWR_FILTER_TYPE_KAISER
	}
	public enum SwsAlphaBlend
	{
		SWS_ALPHA_BLEND_NONE,
		SWS_ALPHA_BLEND_UNIFORM,
		SWS_ALPHA_BLEND_CHECKERBOARD,
		SWS_ALPHA_BLEND_NB
	}
	public enum SwsDither
	{
		SWS_DITHER_NONE,
		SWS_DITHER_AUTO,
		SWS_DITHER_BAYER,
		SWS_DITHER_ED,
		SWS_DITHER_A_DITHER,
		SWS_DITHER_X_DITHER,
		SWS_DITHER_NB
	}
	public enum SwsFlags
	{
		SWS_FAST_BILINEAR = 1,
		SWS_BILINEAR = 2,
		SWS_BICUBIC = 4,
		SWS_X = 8,
		SWS_POINT = 16,
		SWS_AREA = 32,
		SWS_BICUBLIN = 64,
		SWS_GAUSS = 128,
		SWS_SINC = 256,
		SWS_LANCZOS = 512,
		SWS_SPLINE = 1024,
		SWS_STRICT = 2048,
		SWS_PRINT_INFO = 4096,
		SWS_FULL_CHR_H_INT = 8192,
		SWS_FULL_CHR_H_INP = 16384,
		SWS_ACCURATE_RND = 262144,
		SWS_BITEXACT = 524288,
		SWS_DIRECT_BGR = 32768,
		SWS_ERROR_DIFFUSION = 8388608
	}
	public enum SwsIntent
	{
		SWS_INTENT_PERCEPTUAL,
		SWS_INTENT_RELATIVE_COLORIMETRIC,
		SWS_INTENT_SATURATION,
		SWS_INTENT_ABSOLUTE_COLORIMETRIC,
		SWS_INTENT_NB
	}
	public struct _GUID
	{
		public ulong Data1;

		public ushort Data2;

		public ushort Data3;

		public byte_array8 Data4;
	}
	public struct _iobuf
	{
		public unsafe void* _Placeholder;
	}
	public struct AVBitStreamFilter
	{
		public unsafe byte* name;

		public unsafe AVCodecID* codec_ids;

		public unsafe AVClass* priv_class;
	}
	public struct AVBSFContext
	{
		public unsafe AVClass* av_class;

		public unsafe AVBitStreamFilter* filter;

		public unsafe void* priv_data;

		public unsafe AVCodecParameters* par_in;

		public unsafe AVCodecParameters* par_out;

		public AVRational time_base_in;

		public AVRational time_base_out;
	}
	public struct AVBufferRef
	{
		public unsafe AVBuffer* buffer;

		public unsafe byte* data;

		public ulong size;
	}
	public struct AVBufferSrcParameters
	{
		public int format;

		public AVRational time_base;

		public int width;

		public int height;

		public AVRational sample_aspect_ratio;

		public AVRational frame_rate;

		public unsafe AVBufferRef* hw_frames_ctx;

		public int sample_rate;

		public AVChannelLayout ch_layout;

		public AVColorSpace color_space;

		public AVColorRange color_range;

		public unsafe AVFrameSideData** side_data;

		public int nb_side_data;
	}
	public struct AVChannelCustom
	{
		public AVChannel id;

		public byte_array16 name;

		public unsafe void* opaque;
	}
	public struct AVChannelLayout
	{
		public AVChannelOrder order;

		public int nb_channels;

		public AVChannelLayout_u u;

		public unsafe void* opaque;
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct AVChannelLayout_u
	{
		[FieldOffset(0)]
		public ulong mask;

		[FieldOffset(0)]
		public unsafe AVChannelCustom* map;
	}
	public struct AVChapter
	{
		public long id;

		public AVRational time_base;

		public long start;

		public long end;

		public unsafe AVDictionary* metadata;
	}
	public struct AVClass
	{
		public unsafe byte* class_name;

		public AVClass_item_name_func item_name;

		public unsafe AVOption* option;

		public int version;

		public int log_level_offset_offset;

		public int parent_log_context_offset;

		public AVClassCategory category;

		public AVClass_get_category_func get_category;

		public AVClass_query_ranges_func query_ranges;

		public AVClass_child_next_func child_next;

		public AVClass_child_class_iterate_func child_class_iterate;

		public int state_flags_offset;
	}
	public struct AVCodec
	{
		public unsafe byte* name;

		public unsafe byte* long_name;

		public AVMediaType type;

		public AVCodecID id;

		public int capabilities;

		public byte max_lowres;

		[Obsolete("use avcodec_get_supported_config()")]
		public unsafe AVRational* supported_framerates;

		[Obsolete("use avcodec_get_supported_config()")]
		public unsafe AVPixelFormat* pix_fmts;

		[Obsolete("use avcodec_get_supported_config()")]
		public unsafe int* supported_samplerates;

		[Obsolete("use avcodec_get_supported_config()")]
		public unsafe AVSampleFormat* sample_fmts;

		public unsafe AVClass* priv_class;

		public unsafe AVProfile* profiles;

		public unsafe byte* wrapper_name;

		[Obsolete("use avcodec_get_supported_config()")]
		public unsafe AVChannelLayout* ch_layouts;
	}
	public struct AVCodecContext
	{
		public unsafe AVClass* av_class;

		public int log_level_offset;

		public AVMediaType codec_type;

		public unsafe AVCodec* codec;

		public AVCodecID codec_id;

		public uint codec_tag;

		public unsafe void* priv_data;

		public unsafe AVCodecInternal* @internal;

		public unsafe void* opaque;

		public long bit_rate;

		public int flags;

		public int flags2;

		public unsafe byte* extradata;

		public int extradata_size;

		public AVRational time_base;

		public AVRational pkt_timebase;

		public AVRational framerate;

		public int delay;

		public int width;

		public int height;

		public int coded_width;

		public int coded_height;

		public AVRational sample_aspect_ratio;

		public AVPixelFormat pix_fmt;

		public AVPixelFormat sw_pix_fmt;

		public AVColorPrimaries color_primaries;

		public AVColorTransferCharacteristic color_trc;

		public AVColorSpace colorspace;

		public AVColorRange color_range;

		public AVChromaLocation chroma_sample_location;

		public AVFieldOrder field_order;

		public int refs;

		public int has_b_frames;

		public int slice_flags;

		public AVCodecContext_draw_horiz_band_func draw_horiz_band;

		public AVCodecContext_get_format_func get_format;

		public int max_b_frames;

		public float b_quant_factor;

		public float b_quant_offset;

		public float i_quant_factor;

		public float i_quant_offset;

		public float lumi_masking;

		public float temporal_cplx_masking;

		public float spatial_cplx_masking;

		public float p_masking;

		public float dark_masking;

		public int nsse_weight;

		public int me_cmp;

		public int me_sub_cmp;

		public int mb_cmp;

		public int ildct_cmp;

		public int dia_size;

		public int last_predictor_count;

		public int me_pre_cmp;

		public int pre_dia_size;

		public int me_subpel_quality;

		public int me_range;

		public int mb_decision;

		public unsafe ushort* intra_matrix;

		public unsafe ushort* inter_matrix;

		public unsafe ushort* chroma_intra_matrix;

		public int intra_dc_precision;

		public int mb_lmin;

		public int mb_lmax;

		public int bidir_refine;

		public int keyint_min;

		public int gop_size;

		public int mv0_threshold;

		public int slices;

		public int sample_rate;

		public AVSampleFormat sample_fmt;

		public AVChannelLayout ch_layout;

		public int frame_size;

		public int block_align;

		public int cutoff;

		public AVAudioServiceType audio_service_type;

		public AVSampleFormat request_sample_fmt;

		public int initial_padding;

		public int trailing_padding;

		public int seek_preroll;

		public AVCodecContext_get_buffer2_func get_buffer2;

		public int bit_rate_tolerance;

		public int global_quality;

		public int compression_level;

		public float qcompress;

		public float qblur;

		public int qmin;

		public int qmax;

		public int max_qdiff;

		public int rc_buffer_size;

		public int rc_override_count;

		public unsafe RcOverride* rc_override;

		public long rc_max_rate;

		public long rc_min_rate;

		public float rc_max_available_vbv_use;

		public float rc_min_vbv_overflow_use;

		public int rc_initial_buffer_occupancy;

		public int trellis;

		public unsafe byte* stats_out;

		public unsafe byte* stats_in;

		public int workaround_bugs;

		public int strict_std_compliance;

		public int error_concealment;

		public int debug;

		public int err_recognition;

		public unsafe AVHWAccel* hwaccel;

		public unsafe void* hwaccel_context;

		public unsafe AVBufferRef* hw_frames_ctx;

		public unsafe AVBufferRef* hw_device_ctx;

		public int hwaccel_flags;

		public int extra_hw_frames;

		public ulong_array8 error;

		public int dct_algo;

		public int idct_algo;

		public int bits_per_coded_sample;

		public int bits_per_raw_sample;

		public int thread_count;

		public int thread_type;

		public int active_thread_type;

		public AVCodecContext_execute_func execute;

		public AVCodecContext_execute2_func execute2;

		public int profile;

		public int level;

		public uint properties;

		public AVDiscard skip_loop_filter;

		public AVDiscard skip_idct;

		public AVDiscard skip_frame;

		public int skip_alpha;

		public int skip_top;

		public int skip_bottom;

		public int lowres;

		public unsafe AVCodecDescriptor* codec_descriptor;

		public unsafe byte* sub_charenc;

		public int sub_charenc_mode;

		public int subtitle_header_size;

		public unsafe byte* subtitle_header;

		public unsafe byte* dump_separator;

		public unsafe byte* codec_whitelist;

		public unsafe AVPacketSideData* coded_side_data;

		public int nb_coded_side_data;

		public int export_side_data;

		public long max_pixels;

		public int apply_cropping;

		public int discard_damaged_percentage;

		public long max_samples;

		public AVCodecContext_get_encode_buffer_func get_encode_buffer;

		public long frame_num;

		public unsafe int* side_data_prefer_packet;

		public uint nb_side_data_prefer_packet;

		public unsafe AVFrameSideData** decoded_side_data;

		public int nb_decoded_side_data;
	}
	public struct AVCodecDescriptor
	{
		public AVCodecID id;

		public AVMediaType type;

		public unsafe byte* name;

		public unsafe byte* long_name;

		public int props;

		public unsafe byte** mime_types;

		public unsafe AVProfile* profiles;
	}
	public struct AVCodecHWConfig
	{
		public AVPixelFormat pix_fmt;

		public int methods;

		public AVHWDeviceType device_type;
	}
	public struct AVCodecParameters
	{
		public AVMediaType codec_type;

		public AVCodecID codec_id;

		public uint codec_tag;

		public unsafe byte* extradata;

		public int extradata_size;

		public unsafe AVPacketSideData* coded_side_data;

		public int nb_coded_side_data;

		public int format;

		public long bit_rate;

		public int bits_per_coded_sample;

		public int bits_per_raw_sample;

		public int profile;

		public int level;

		public int width;

		public int height;

		public AVRational sample_aspect_ratio;

		public AVRational framerate;

		public AVFieldOrder field_order;

		public AVColorRange color_range;

		public AVColorPrimaries color_primaries;

		public AVColorTransferCharacteristic color_trc;

		public AVColorSpace color_space;

		public AVChromaLocation chroma_location;

		public int video_delay;

		public AVChannelLayout ch_layout;

		public int sample_rate;

		public int block_align;

		public int frame_size;

		public int initial_padding;

		public int trailing_padding;

		public int seek_preroll;
	}
	public struct AVCodecParser
	{
		public int_array7 codec_ids;

		public int priv_data_size;

		public AVCodecParser_parser_init_func parser_init;

		public AVCodecParser_parser_parse_func parser_parse;

		public AVCodecParser_parser_close_func parser_close;

		public AVCodecParser_split_func split;
	}
	public struct AVCodecParserContext
	{
		public unsafe void* priv_data;

		public unsafe AVCodecParser* parser;

		public long frame_offset;

		public long cur_offset;

		public long next_frame_offset;

		public int pict_type;

		public int repeat_pict;

		public long pts;

		public long dts;

		public long last_pts;

		public long last_dts;

		public int fetch_timestamp;

		public int cur_frame_start_index;

		public long_array4 cur_frame_offset;

		public long_array4 cur_frame_pts;

		public long_array4 cur_frame_dts;

		public int flags;

		public long offset;

		public long_array4 cur_frame_end;

		public int key_frame;

		public int dts_sync_point;

		public int dts_ref_dts_delta;

		public int pts_dts_delta;

		public long_array4 cur_frame_pos;

		public long pos;

		public long last_pos;

		public int duration;

		public AVFieldOrder field_order;

		public AVPictureStructure picture_structure;

		public int output_picture_number;

		public int width;

		public int height;

		public int coded_width;

		public int coded_height;

		public int format;
	}
	public struct AVComponentDescriptor
	{
		public int plane;

		public int step;

		public int offset;

		public int shift;

		public int depth;
	}
	public struct AVContentLightMetadata
	{
		public uint MaxCLL;

		public uint MaxFALL;
	}
	public struct AVCPBProperties
	{
		public long max_bitrate;

		public long min_bitrate;

		public long avg_bitrate;

		public long buffer_size;

		public ulong vbv_delay;
	}
	public struct AVD3D11FrameDescriptor
	{
		public unsafe ID3D11Texture2D* texture;

		public long index;
	}
	public struct AVD3D11VAContext
	{
		public unsafe ID3D11VideoDecoder* decoder;

		public unsafe ID3D11VideoContext* video_context;

		public unsafe D3D11_VIDEO_DECODER_CONFIG* cfg;

		public uint surface_count;

		public unsafe ID3D11VideoDecoderOutputView** surface;

		public ulong workaround;

		public uint report_id;

		public unsafe void* context_mutex;
	}
	public struct AVD3D11VADeviceContext
	{
		public unsafe ID3D11Device* device;

		public unsafe ID3D11DeviceContext* device_context;

		public unsafe ID3D11VideoDevice* video_device;

		public unsafe ID3D11VideoContext* video_context;

		public AVD3D11VADeviceContext_lock_func @lock;

		public AVD3D11VADeviceContext_unlock_func unlock;

		public unsafe void* lock_ctx;
	}
	public struct AVD3D11VAFramesContext
	{
		public unsafe ID3D11Texture2D* texture;

		public uint BindFlags;

		public uint MiscFlags;

		public unsafe AVD3D11FrameDescriptor* texture_infos;
	}
	public struct AVDeviceInfo
	{
		public unsafe byte* device_name;

		public unsafe byte* device_description;

		public unsafe AVMediaType* media_types;

		public int nb_media_types;
	}
	public struct AVDeviceInfoList
	{
		public unsafe AVDeviceInfo** devices;

		public int nb_devices;

		public int default_device;
	}
	public struct AVDeviceRect
	{
		public int x;

		public int y;

		public int width;

		public int height;
	}
	public struct AVDictionaryEntry
	{
		public unsafe byte* key;

		public unsafe byte* value;
	}
	public struct AVDXVA2DeviceContext
	{
		public unsafe IDirect3DDeviceManager9* devmgr;
	}
	public struct AVDXVA2FramesContext
	{
		public ulong surface_type;

		public unsafe IDirect3DSurface9** surfaces;

		public int nb_surfaces;

		public unsafe IDirectXVideoDecoder* decoder_to_release;
	}
	public struct AVDynamicHDRPlus
	{
		public byte itu_t_t35_country_code;

		public byte application_version;

		public byte num_windows;

		public AVHDRPlusColorTransformParams_array3 @params;

		public AVRational targeted_system_display_maximum_luminance;

		public byte targeted_system_display_actual_peak_luminance_flag;

		public byte num_rows_targeted_system_display_actual_peak_luminance;

		public byte num_cols_targeted_system_display_actual_peak_luminance;

		public AVRational_array25x25 targeted_system_display_actual_peak_luminance;

		public byte mastering_display_actual_peak_luminance_flag;

		public byte num_rows_mastering_display_actual_peak_luminance;

		public byte num_cols_mastering_display_actual_peak_luminance;

		public AVRational_array25x25 mastering_display_actual_peak_luminance;
	}
	public struct AVFilter
	{
		public unsafe byte* name;

		public unsafe byte* description;

		public unsafe AVFilterPad* inputs;

		public unsafe AVFilterPad* outputs;

		public unsafe AVClass* priv_class;

		public int flags;
	}
	public struct AVFilterChain
	{
		public unsafe AVFilterParams** filters;

		public ulong nb_filters;
	}
	public struct AVFilterContext
	{
		public unsafe AVClass* av_class;

		public unsafe AVFilter* filter;

		public unsafe byte* name;

		public unsafe AVFilterPad* input_pads;

		public unsafe AVFilterLink** inputs;

		public uint nb_inputs;

		public unsafe AVFilterPad* output_pads;

		public unsafe AVFilterLink** outputs;

		public uint nb_outputs;

		public unsafe void* priv;

		public unsafe AVFilterGraph* graph;

		public int thread_type;

		public int nb_threads;

		[Obsolete("unused")]
		public unsafe AVFilterCommand* command_queue;

		public unsafe byte* enable_str;

		[Obsolete("unused")]
		public unsafe void* enable;

		[Obsolete("unused")]
		public unsafe double* var_values;

		public int is_disabled;

		public unsafe AVBufferRef* hw_device_ctx;

		[Obsolete("this field should never have been accessed by callers")]
		public uint ready;

		public int extra_hw_frames;
	}
	public struct AVFilterFormatsConfig
	{
		public unsafe AVFilterFormats* formats;

		public unsafe AVFilterFormats* samplerates;

		public unsafe AVFilterChannelLayouts* channel_layouts;

		public unsafe AVFilterFormats* color_spaces;

		public unsafe AVFilterFormats* color_ranges;
	}
	public struct AVFilterGraph
	{
		public unsafe AVClass* av_class;

		public unsafe AVFilterContext** filters;

		public uint nb_filters;

		public unsafe byte* scale_sws_opts;

		public int thread_type;

		public int nb_threads;

		public unsafe void* opaque;

		public AVFilterGraph_execute_func execute;

		public unsafe byte* aresample_swr_opts;

		public uint max_buffered_frames;
	}
	public struct AVFilterGraphSegment
	{
		public unsafe AVFilterGraph* graph;

		public unsafe AVFilterChain** chains;

		public ulong nb_chains;

		public unsafe byte* scale_sws_opts;
	}
	public struct AVFilterInOut
	{
		public unsafe byte* name;

		public unsafe AVFilterContext* filter_ctx;

		public int pad_idx;

		public unsafe AVFilterInOut* next;
	}
	public struct AVFilterLink
	{
		public unsafe AVFilterContext* src;

		public unsafe AVFilterPad* srcpad;

		public unsafe AVFilterContext* dst;

		public unsafe AVFilterPad* dstpad;

		public AVMediaType type;

		public int format;

		public int w;

		public int h;

		public AVRational sample_aspect_ratio;

		public AVColorSpace colorspace;

		public AVColorRange color_range;

		public int sample_rate;

		public AVChannelLayout ch_layout;

		public AVRational time_base;

		public unsafe AVFrameSideData** side_data;

		public int nb_side_data;

		public AVFilterFormatsConfig incfg;

		public AVFilterFormatsConfig outcfg;
	}
	public struct AVFilterPadParams
	{
		public unsafe byte* label;
	}
	public struct AVFilterParams
	{
		public unsafe AVFilterContext* filter;

		public unsafe byte* filter_name;

		public unsafe byte* instance_name;

		public unsafe AVDictionary* opts;

		public unsafe AVFilterPadParams** inputs;

		public uint nb_inputs;

		public unsafe AVFilterPadParams** outputs;

		public uint nb_outputs;
	}
	public struct AVFormatContext
	{
		public unsafe AVClass* av_class;

		public unsafe AVInputFormat* iformat;

		public unsafe AVOutputFormat* oformat;

		public unsafe void* priv_data;

		public unsafe AVIOContext* pb;

		public int ctx_flags;

		public uint nb_streams;

		public unsafe AVStream** streams;

		public uint nb_stream_groups;

		public unsafe AVStreamGroup** stream_groups;

		public uint nb_chapters;

		public unsafe AVChapter** chapters;

		public unsafe byte* url;

		public long start_time;

		public long duration;

		public long bit_rate;

		public uint packet_size;

		public int max_delay;

		public int flags;

		public long probesize;

		public long max_analyze_duration;

		public unsafe byte* key;

		public int keylen;

		public uint nb_programs;

		public unsafe AVProgram** programs;

		public AVCodecID video_codec_id;

		public AVCodecID audio_codec_id;

		public AVCodecID subtitle_codec_id;

		public AVCodecID data_codec_id;

		public unsafe AVDictionary* metadata;

		public long start_time_realtime;

		public int fps_probe_size;

		public int error_recognition;

		public AVIOInterruptCB interrupt_callback;

		public int debug;

		public int max_streams;

		public uint max_index_size;

		public uint max_picture_buffer;

		public long max_interleave_delta;

		public int max_ts_probe;

		public int max_chunk_duration;

		public int max_chunk_size;

		public int max_probe_packets;

		public int strict_std_compliance;

		public int event_flags;

		public int avoid_negative_ts;

		public int audio_preload;

		public int use_wallclock_as_timestamps;

		public int skip_estimate_duration_from_pts;

		public int avio_flags;

		public AVDurationEstimationMethod duration_estimation_method;

		public long skip_initial_bytes;

		public uint correct_ts_overflow;

		public int seek2any;

		public int flush_packets;

		public int probe_score;

		public int format_probesize;

		public unsafe byte* codec_whitelist;

		public unsafe byte* format_whitelist;

		public unsafe byte* protocol_whitelist;

		public unsafe byte* protocol_blacklist;

		public int io_repositioned;

		public unsafe AVCodec* video_codec;

		public unsafe AVCodec* audio_codec;

		public unsafe AVCodec* subtitle_codec;

		public unsafe AVCodec* data_codec;

		public int metadata_header_padding;

		public unsafe void* opaque;

		public AVFormatContext_control_message_cb_func control_message_cb;

		public long output_ts_offset;

		public unsafe byte* dump_separator;

		public AVFormatContext_io_open_func io_open;

		public AVFormatContext_io_close2_func io_close2;

		public long duration_probesize;
	}
	public struct AVFrame
	{
		public byte_ptrArray8 data;

		public int_array8 linesize;

		public unsafe byte** extended_data;

		public int width;

		public int height;

		public int nb_samples;

		public int format;

		public AVPictureType pict_type;

		public AVRational sample_aspect_ratio;

		public long pts;

		public long pkt_dts;

		public AVRational time_base;

		public int quality;

		public unsafe void* opaque;

		public int repeat_pict;

		public int sample_rate;

		public AVBufferRef_ptrArray8 buf;

		public unsafe AVBufferRef** extended_buf;

		public int nb_extended_buf;

		public unsafe AVFrameSideData** side_data;

		public int nb_side_data;

		public int flags;

		public AVColorRange color_range;

		public AVColorPrimaries color_primaries;

		public AVColorTransferCharacteristic color_trc;

		public AVColorSpace colorspace;

		public AVChromaLocation chroma_location;

		public long best_effort_timestamp;

		public unsafe AVDictionary* metadata;

		public int decode_error_flags;

		public unsafe AVBufferRef* hw_frames_ctx;

		public unsafe AVBufferRef* opaque_ref;

		public ulong crop_top;

		public ulong crop_bottom;

		public ulong crop_left;

		public ulong crop_right;

		public unsafe void* private_ref;

		public AVChannelLayout ch_layout;

		public long duration;
	}
	public struct AVFrameSideData
	{
		public AVFrameSideDataType type;

		public unsafe byte* data;

		public ulong size;

		public unsafe AVDictionary* metadata;

		public unsafe AVBufferRef* buf;
	}
	public struct AVHDRPlusColorTransformParams
	{
		public AVRational window_upper_left_corner_x;

		public AVRational window_upper_left_corner_y;

		public AVRational window_lower_right_corner_x;

		public AVRational window_lower_right_corner_y;

		public ushort center_of_ellipse_x;

		public ushort center_of_ellipse_y;

		public byte rotation_angle;

		public ushort semimajor_axis_internal_ellipse;

		public ushort semimajor_axis_external_ellipse;

		public ushort semiminor_axis_external_ellipse;

		public AVHDRPlusOverlapProcessOption overlap_process_option;

		public AVRational_array3 maxscl;

		public AVRational average_maxrgb;

		public byte num_distribution_maxrgb_percentiles;

		public AVHDRPlusPercentile_array15 distribution_maxrgb;

		public AVRational fraction_bright_pixels;

		public byte tone_mapping_flag;

		public AVRational knee_point_x;

		public AVRational knee_point_y;

		public byte num_bezier_curve_anchors;

		public AVRational_array15 bezier_curve_anchors;

		public byte color_saturation_mapping_flag;

		public AVRational color_saturation_weight;
	}
	public struct AVHDRPlusPercentile
	{
		public byte percentage;

		public AVRational percentile;
	}
	public struct AVHWAccel
	{
		public unsafe byte* name;

		public AVMediaType type;

		public AVCodecID id;

		public AVPixelFormat pix_fmt;

		public int capabilities;
	}
	public struct AVHWDeviceContext
	{
		public unsafe AVClass* av_class;

		public AVHWDeviceType type;

		public unsafe void* hwctx;

		public AVHWDeviceContext_free_func free;

		public unsafe void* user_opaque;
	}
	public struct AVHWFramesConstraints
	{
		public unsafe AVPixelFormat* valid_hw_formats;

		public unsafe AVPixelFormat* valid_sw_formats;

		public int min_width;

		public int min_height;

		public int max_width;

		public int max_height;
	}
	public struct AVHWFramesContext
	{
		public unsafe AVClass* av_class;

		public unsafe AVBufferRef* device_ref;

		public unsafe AVHWDeviceContext* device_ctx;

		public unsafe void* hwctx;

		public AVHWFramesContext_free_func free;

		public unsafe void* user_opaque;

		public unsafe AVBufferPool* pool;

		public int initial_pool_size;

		public AVPixelFormat format;

		public AVPixelFormat sw_format;

		public int width;

		public int height;
	}
	public struct AVIndexEntry
	{
		public long pos;

		public long timestamp;

		public int flags2_size30;

		public int min_distance;
	}
	public struct AVInputFormat
	{
		public unsafe byte* name;

		public unsafe byte* long_name;

		public int flags;

		public unsafe byte* extensions;

		public unsafe AVCodecTag** codec_tag;

		public unsafe AVClass* priv_class;

		public unsafe byte* mime_type;
	}
	public struct AVIOContext
	{
		public unsafe AVClass* av_class;

		public unsafe byte* buffer;

		public int buffer_size;

		public unsafe byte* buf_ptr;

		public unsafe byte* buf_end;

		public unsafe void* opaque;

		public AVIOContext_read_packet_func read_packet;

		public AVIOContext_write_packet_func write_packet;

		public AVIOContext_seek_func seek;

		public long pos;

		public int eof_reached;

		public int error;

		public int write_flag;

		public int max_packet_size;

		public int min_packet_size;

		public ulong checksum;

		public unsafe byte* checksum_ptr;

		public AVIOContext_update_checksum_func update_checksum;

		public AVIOContext_read_pause_func read_pause;

		public AVIOContext_read_seek_func read_seek;

		public int seekable;

		public int direct;

		public unsafe byte* protocol_whitelist;

		public unsafe byte* protocol_blacklist;

		public AVIOContext_write_data_type_func write_data_type;

		public int ignore_boundary_point;

		public unsafe byte* buf_ptr_max;

		public long bytes_read;

		public long bytes_written;
	}
	public struct AVIODirEntry
	{
		public unsafe byte* name;

		public int type;

		public int utf8;

		public long size;

		public long modification_timestamp;

		public long access_timestamp;

		public long status_change_timestamp;

		public long user_id;

		public long group_id;

		public long filemode;
	}
	public struct AVIOInterruptCB
	{
		public AVIOInterruptCB_callback_func callback;

		public unsafe void* opaque;
	}
	public struct AVMasteringDisplayMetadata
	{
		public AVRational_array3x2 display_primaries;

		public AVRational_array2 white_point;

		public AVRational min_luminance;

		public AVRational max_luminance;

		public int has_primaries;

		public int has_luminance;
	}
	public struct AVOption
	{
		public unsafe byte* name;

		public unsafe byte* help;

		public int offset;

		public AVOptionType type;

		public AVOption_default_val default_val;

		public double min;

		public double max;

		public int flags;

		public unsafe byte* unit;
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct AVOption_default_val
	{
		[FieldOffset(0)]
		public long i64;

		[FieldOffset(0)]
		public double dbl;

		[FieldOffset(0)]
		public unsafe byte* str;

		[FieldOffset(0)]
		public AVRational q;

		[FieldOffset(0)]
		public unsafe AVOptionArrayDef* arr;
	}
	public struct AVOptionArrayDef
	{
		public unsafe byte* def;

		public uint size_min;

		public uint size_max;

		public byte sep;
	}
	public struct AVOptionRange
	{
		public unsafe byte* str;

		public double value_min;

		public double value_max;

		public double component_min;

		public double component_max;

		public int is_range;
	}
	public struct AVOptionRanges
	{
		public unsafe AVOptionRange** range;

		public int nb_ranges;

		public int nb_components;
	}
	public struct AVOutputFormat
	{
		public unsafe byte* name;

		public unsafe byte* long_name;

		public unsafe byte* mime_type;

		public unsafe byte* extensions;

		public AVCodecID audio_codec;

		public AVCodecID video_codec;

		public AVCodecID subtitle_codec;

		public int flags;

		public unsafe AVCodecTag** codec_tag;

		public unsafe AVClass* priv_class;
	}
	public struct AVPacket
	{
		public unsafe AVBufferRef* buf;

		public long pts;

		public long dts;

		public unsafe byte* data;

		public int size;

		public int stream_index;

		public int flags;

		public unsafe AVPacketSideData* side_data;

		public int side_data_elems;

		public long duration;

		public long pos;

		public unsafe void* opaque;

		public unsafe AVBufferRef* opaque_ref;

		public AVRational time_base;
	}
	public struct AVPacketList
	{
		public AVPacket pkt;

		public unsafe AVPacketList* next;
	}
	public struct AVPacketSideData
	{
		public unsafe byte* data;

		public ulong size;

		public AVPacketSideDataType type;
	}
	public struct AVPanScan
	{
		public int id;

		public int width;

		public int height;

		public short_array3x2 position;
	}
	public struct AVPixFmtDescriptor
	{
		public unsafe byte* name;

		public byte nb_components;

		public byte log2_chroma_w;

		public byte log2_chroma_h;

		public ulong flags;

		public AVComponentDescriptor_array4 comp;

		public unsafe byte* alias;
	}
	public struct AVProbeData
	{
		public unsafe byte* filename;

		public unsafe byte* buf;

		public int buf_size;

		public unsafe byte* mime_type;
	}
	public struct AVProducerReferenceTime
	{
		public long wallclock;

		public int flags;
	}
	public struct AVProfile
	{
		public int profile;

		public unsafe byte* name;
	}
	public struct AVProgram
	{
		public int id;

		public int flags;

		public AVDiscard discard;

		public unsafe uint* stream_index;

		public uint nb_stream_indexes;

		public unsafe AVDictionary* metadata;

		public int program_num;

		public int pmt_pid;

		public int pcr_pid;

		public int pmt_version;

		public long start_time;

		public long end_time;

		public long pts_wrap_reference;

		public int pts_wrap_behavior;
	}
	public struct AVRational
	{
		public int num;

		public int den;
	}
	public struct AVRegionOfInterest
	{
		public uint self_size;

		public int top;

		public int bottom;

		public int left;

		public int right;

		public AVRational qoffset;
	}
	public struct AVRTCPSenderReport
	{
		public uint ssrc;

		public ulong ntp_timestamp;

		public uint rtp_timestamp;

		public uint sender_nb_packets;

		public uint sender_nb_bytes;
	}
	public struct AVSideDataDescriptor
	{
		public unsafe byte* name;

		public uint props;
	}
	public struct AVStream
	{
		public unsafe AVClass* av_class;

		public int index;

		public int id;

		public unsafe AVCodecParameters* codecpar;

		public unsafe void* priv_data;

		public AVRational time_base;

		public long start_time;

		public long duration;

		public long nb_frames;

		public int disposition;

		public AVDiscard discard;

		public AVRational sample_aspect_ratio;

		public unsafe AVDictionary* metadata;

		public AVRational avg_frame_rate;

		public AVPacket attached_pic;

		public int event_flags;

		public AVRational r_frame_rate;

		public int pts_wrap_bits;
	}
	public struct AVStreamGroup
	{
		public unsafe AVClass* av_class;

		public unsafe void* priv_data;

		public uint index;

		public long id;

		public AVStreamGroupParamsType type;

		public AVStreamGroup_params @params;

		public unsafe AVDictionary* metadata;

		public uint nb_streams;

		public unsafe AVStream** streams;

		public int disposition;
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct AVStreamGroup_params
	{
		[FieldOffset(0)]
		public unsafe AVIAMFAudioElement* iamf_audio_element;

		[FieldOffset(0)]
		public unsafe AVIAMFMixPresentation* iamf_mix_presentation;

		[FieldOffset(0)]
		public unsafe AVStreamGroupTileGrid* tile_grid;

		[FieldOffset(0)]
		public unsafe AVStreamGroupLCEVC* lcevc;
	}
	public struct AVStreamGroupLCEVC
	{
		public unsafe AVClass* av_class;

		public uint lcevc_index;

		public int width;

		public int height;
	}
	public struct AVStreamGroupTileGrid
	{
		public unsafe AVClass* av_class;

		public uint nb_tiles;

		public int coded_width;

		public int coded_height;

		public unsafe AVStreamGroupTileGrid_offsets* offsets;

		public byte_array4 background;

		public int horizontal_offset;

		public int vertical_offset;

		public int width;

		public int height;

		public unsafe AVPacketSideData* coded_side_data;

		public int nb_coded_side_data;
	}
	public struct AVStreamGroupTileGrid_offsets
	{
		public uint idx;

		public int horizontal;

		public int vertical;
	}
	public struct AVSubtitle
	{
		public ushort format;

		public uint start_display_time;

		public uint end_display_time;

		public uint num_rects;

		public unsafe AVSubtitleRect** rects;

		public long pts;
	}
	public struct AVSubtitleRect
	{
		public int x;

		public int y;

		public int w;

		public int h;

		public int nb_colors;

		public byte_ptrArray4 data;

		public int_array4 linesize;

		public int flags;

		public AVSubtitleType type;

		public unsafe byte* text;

		public unsafe byte* ass;
	}
	public struct AVTimecode
	{
		public int start;

		public uint flags;

		public AVRational rate;

		public uint fps;
	}
	public struct D3D11_VIDEO_DECODER_CONFIG
	{
		public _GUID guidConfigBitstreamEncryption;

		public _GUID guidConfigMBcontrolEncryption;

		public _GUID guidConfigResidDiffEncryption;

		public uint ConfigBitstreamRaw;

		public uint ConfigMBcontrolRasterOrder;

		public uint ConfigResidDiffHost;

		public uint ConfigSpatialResid8;

		public uint ConfigResid8Subtraction;

		public uint ConfigSpatialHost8or9Clipping;

		public uint ConfigSpatialResidInterleaved;

		public uint ConfigIntraResidUnsigned;

		public uint ConfigResidDiffAccelerator;

		public uint ConfigHostInverseScan;

		public uint ConfigSpecificIDCT;

		public uint Config4GroupedCoefs;

		public ushort ConfigMinRenderTargetBuffCount;

		public ushort ConfigDecoderSpecific;
	}
	public struct ID3D11Device
	{
		public unsafe ID3D11DeviceVtbl* lpVtbl;
	}
	public struct ID3D11DeviceContext
	{
		public unsafe ID3D11DeviceContextVtbl* lpVtbl;
	}
	public struct ID3D11DeviceContextVtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* GetDevice;

		public unsafe void* GetPrivateData;

		public unsafe void* SetPrivateData;

		public unsafe void* SetPrivateDataInterface;

		public unsafe void* VSSetConstantBuffers;

		public unsafe void* PSSetShaderResources;

		public unsafe void* PSSetShader;

		public unsafe void* PSSetSamplers;

		public unsafe void* VSSetShader;

		public unsafe void* DrawIndexed;

		public unsafe void* Draw;

		public unsafe void* Map;

		public unsafe void* Unmap;

		public unsafe void* PSSetConstantBuffers;

		public unsafe void* IASetInputLayout;

		public unsafe void* IASetVertexBuffers;

		public unsafe void* IASetIndexBuffer;

		public unsafe void* DrawIndexedInstanced;

		public unsafe void* DrawInstanced;

		public unsafe void* GSSetConstantBuffers;

		public unsafe void* GSSetShader;

		public unsafe void* IASetPrimitiveTopology;

		public unsafe void* VSSetShaderResources;

		public unsafe void* VSSetSamplers;

		public unsafe void* Begin;

		public unsafe void* End;

		public unsafe void* GetData;

		public unsafe void* SetPredication;

		public unsafe void* GSSetShaderResources;

		public unsafe void* GSSetSamplers;

		public unsafe void* OMSetRenderTargets;

		public unsafe void* OMSetRenderTargetsAndUnorderedAccessViews;

		public unsafe void* OMSetBlendState;

		public unsafe void* OMSetDepthStencilState;

		public unsafe void* SOSetTargets;

		public unsafe void* DrawAuto;

		public unsafe void* DrawIndexedInstancedIndirect;

		public unsafe void* DrawInstancedIndirect;

		public unsafe void* Dispatch;

		public unsafe void* DispatchIndirect;

		public unsafe void* RSSetState;

		public unsafe void* RSSetViewports;

		public unsafe void* RSSetScissorRects;

		public unsafe void* CopySubresourceRegion;

		public unsafe void* CopyResource;

		public unsafe void* UpdateSubresource;

		public unsafe void* CopyStructureCount;

		public unsafe void* ClearRenderTargetView;

		public unsafe void* ClearUnorderedAccessViewUint;

		public unsafe void* ClearUnorderedAccessViewFloat;

		public unsafe void* ClearDepthStencilView;

		public unsafe void* GenerateMips;

		public unsafe void* SetResourceMinLOD;

		public unsafe void* GetResourceMinLOD;

		public unsafe void* ResolveSubresource;

		public unsafe void* ExecuteCommandList;

		public unsafe void* HSSetShaderResources;

		public unsafe void* HSSetShader;

		public unsafe void* HSSetSamplers;

		public unsafe void* HSSetConstantBuffers;

		public unsafe void* DSSetShaderResources;

		public unsafe void* DSSetShader;

		public unsafe void* DSSetSamplers;

		public unsafe void* DSSetConstantBuffers;

		public unsafe void* CSSetShaderResources;

		public unsafe void* CSSetUnorderedAccessViews;

		public unsafe void* CSSetShader;

		public unsafe void* CSSetSamplers;

		public unsafe void* CSSetConstantBuffers;

		public unsafe void* VSGetConstantBuffers;

		public unsafe void* PSGetShaderResources;

		public unsafe void* PSGetShader;

		public unsafe void* PSGetSamplers;

		public unsafe void* VSGetShader;

		public unsafe void* PSGetConstantBuffers;

		public unsafe void* IAGetInputLayout;

		public unsafe void* IAGetVertexBuffers;

		public unsafe void* IAGetIndexBuffer;

		public unsafe void* GSGetConstantBuffers;

		public unsafe void* GSGetShader;

		public unsafe void* IAGetPrimitiveTopology;

		public unsafe void* VSGetShaderResources;

		public unsafe void* VSGetSamplers;

		public unsafe void* GetPredication;

		public unsafe void* GSGetShaderResources;

		public unsafe void* GSGetSamplers;

		public unsafe void* OMGetRenderTargets;

		public unsafe void* OMGetRenderTargetsAndUnorderedAccessViews;

		public unsafe void* OMGetBlendState;

		public unsafe void* OMGetDepthStencilState;

		public unsafe void* SOGetTargets;

		public unsafe void* RSGetState;

		public unsafe void* RSGetViewports;

		public unsafe void* RSGetScissorRects;

		public unsafe void* HSGetShaderResources;

		public unsafe void* HSGetShader;

		public unsafe void* HSGetSamplers;

		public unsafe void* HSGetConstantBuffers;

		public unsafe void* DSGetShaderResources;

		public unsafe void* DSGetShader;

		public unsafe void* DSGetSamplers;

		public unsafe void* DSGetConstantBuffers;

		public unsafe void* CSGetShaderResources;

		public unsafe void* CSGetUnorderedAccessViews;

		public unsafe void* CSGetShader;

		public unsafe void* CSGetSamplers;

		public unsafe void* CSGetConstantBuffers;

		public unsafe void* ClearState;

		public unsafe void* Flush;

		public new unsafe void* GetType;

		public unsafe void* GetContextFlags;

		public unsafe void* FinishCommandList;
	}
	public struct ID3D11DeviceVtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* CreateBuffer;

		public unsafe void* CreateTexture1D;

		public unsafe void* CreateTexture2D;

		public unsafe void* CreateTexture3D;

		public unsafe void* CreateShaderResourceView;

		public unsafe void* CreateUnorderedAccessView;

		public unsafe void* CreateRenderTargetView;

		public unsafe void* CreateDepthStencilView;

		public unsafe void* CreateInputLayout;

		public unsafe void* CreateVertexShader;

		public unsafe void* CreateGeometryShader;

		public unsafe void* CreateGeometryShaderWithStreamOutput;

		public unsafe void* CreatePixelShader;

		public unsafe void* CreateHullShader;

		public unsafe void* CreateDomainShader;

		public unsafe void* CreateComputeShader;

		public unsafe void* CreateClassLinkage;

		public unsafe void* CreateBlendState;

		public unsafe void* CreateDepthStencilState;

		public unsafe void* CreateRasterizerState;

		public unsafe void* CreateSamplerState;

		public unsafe void* CreateQuery;

		public unsafe void* CreatePredicate;

		public unsafe void* CreateCounter;

		public unsafe void* CreateDeferredContext;

		public unsafe void* OpenSharedResource;

		public unsafe void* CheckFormatSupport;

		public unsafe void* CheckMultisampleQualityLevels;

		public unsafe void* CheckCounterInfo;

		public unsafe void* CheckCounter;

		public unsafe void* CheckFeatureSupport;

		public unsafe void* GetPrivateData;

		public unsafe void* SetPrivateData;

		public unsafe void* SetPrivateDataInterface;

		public unsafe void* GetFeatureLevel;

		public unsafe void* GetCreationFlags;

		public unsafe void* GetDeviceRemovedReason;

		public unsafe void* GetImmediateContext;

		public unsafe void* SetExceptionMode;

		public unsafe void* GetExceptionMode;
	}
	public struct ID3D11Texture2D
	{
		public unsafe ID3D11Texture2DVtbl* lpVtbl;
	}
	public struct ID3D11Texture2DVtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* GetDevice;

		public unsafe void* GetPrivateData;

		public unsafe void* SetPrivateData;

		public unsafe void* SetPrivateDataInterface;

		public new unsafe void* GetType;

		public unsafe void* SetEvictionPriority;

		public unsafe void* GetEvictionPriority;

		public unsafe void* GetDesc;
	}
	public struct ID3D11VideoContext
	{
		public unsafe ID3D11VideoContextVtbl* lpVtbl;
	}
	public struct ID3D11VideoContextVtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* GetDevice;

		public unsafe void* GetPrivateData;

		public unsafe void* SetPrivateData;

		public unsafe void* SetPrivateDataInterface;

		public unsafe void* GetDecoderBuffer;

		public unsafe void* ReleaseDecoderBuffer;

		public unsafe void* DecoderBeginFrame;

		public unsafe void* DecoderEndFrame;

		public unsafe void* SubmitDecoderBuffers;

		public unsafe void* DecoderExtension;

		public unsafe void* VideoProcessorSetOutputTargetRect;

		public unsafe void* VideoProcessorSetOutputBackgroundColor;

		public unsafe void* VideoProcessorSetOutputColorSpace;

		public unsafe void* VideoProcessorSetOutputAlphaFillMode;

		public unsafe void* VideoProcessorSetOutputConstriction;

		public unsafe void* VideoProcessorSetOutputStereoMode;

		public unsafe void* VideoProcessorSetOutputExtension;

		public unsafe void* VideoProcessorGetOutputTargetRect;

		public unsafe void* VideoProcessorGetOutputBackgroundColor;

		public unsafe void* VideoProcessorGetOutputColorSpace;

		public unsafe void* VideoProcessorGetOutputAlphaFillMode;

		public unsafe void* VideoProcessorGetOutputConstriction;

		public unsafe void* VideoProcessorGetOutputStereoMode;

		public unsafe void* VideoProcessorGetOutputExtension;

		public unsafe void* VideoProcessorSetStreamFrameFormat;

		public unsafe void* VideoProcessorSetStreamColorSpace;

		public unsafe void* VideoProcessorSetStreamOutputRate;

		public unsafe void* VideoProcessorSetStreamSourceRect;

		public unsafe void* VideoProcessorSetStreamDestRect;

		public unsafe void* VideoProcessorSetStreamAlpha;

		public unsafe void* VideoProcessorSetStreamPalette;

		public unsafe void* VideoProcessorSetStreamPixelAspectRatio;

		public unsafe void* VideoProcessorSetStreamLumaKey;

		public unsafe void* VideoProcessorSetStreamStereoFormat;

		public unsafe void* VideoProcessorSetStreamAutoProcessingMode;

		public unsafe void* VideoProcessorSetStreamFilter;

		public unsafe void* VideoProcessorSetStreamExtension;

		public unsafe void* VideoProcessorGetStreamFrameFormat;

		public unsafe void* VideoProcessorGetStreamColorSpace;

		public unsafe void* VideoProcessorGetStreamOutputRate;

		public unsafe void* VideoProcessorGetStreamSourceRect;

		public unsafe void* VideoProcessorGetStreamDestRect;

		public unsafe void* VideoProcessorGetStreamAlpha;

		public unsafe void* VideoProcessorGetStreamPalette;

		public unsafe void* VideoProcessorGetStreamPixelAspectRatio;

		public unsafe void* VideoProcessorGetStreamLumaKey;

		public unsafe void* VideoProcessorGetStreamStereoFormat;

		public unsafe void* VideoProcessorGetStreamAutoProcessingMode;

		public unsafe void* VideoProcessorGetStreamFilter;

		public unsafe void* VideoProcessorGetStreamExtension;

		public unsafe void* VideoProcessorBlt;

		public unsafe void* NegotiateCryptoSessionKeyExchange;

		public unsafe void* EncryptionBlt;

		public unsafe void* DecryptionBlt;

		public unsafe void* StartSessionKeyRefresh;

		public unsafe void* FinishSessionKeyRefresh;

		public unsafe void* GetEncryptionBltKey;

		public unsafe void* NegotiateAuthenticatedChannelKeyExchange;

		public unsafe void* QueryAuthenticatedChannel;

		public unsafe void* ConfigureAuthenticatedChannel;

		public unsafe void* VideoProcessorSetStreamRotation;

		public unsafe void* VideoProcessorGetStreamRotation;
	}
	public struct ID3D11VideoDecoder
	{
		public unsafe ID3D11VideoDecoderVtbl* lpVtbl;
	}
	public struct ID3D11VideoDecoderOutputView
	{
		public unsafe ID3D11VideoDecoderOutputViewVtbl* lpVtbl;
	}
	public struct ID3D11VideoDecoderOutputViewVtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* GetDevice;

		public unsafe void* GetPrivateData;

		public unsafe void* SetPrivateData;

		public unsafe void* SetPrivateDataInterface;

		public unsafe void* GetResource;

		public unsafe void* GetDesc;
	}
	public struct ID3D11VideoDecoderVtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* GetDevice;

		public unsafe void* GetPrivateData;

		public unsafe void* SetPrivateData;

		public unsafe void* SetPrivateDataInterface;

		public unsafe void* GetCreationParameters;

		public unsafe void* GetDriverHandle;
	}
	public struct ID3D11VideoDevice
	{
		public unsafe ID3D11VideoDeviceVtbl* lpVtbl;
	}
	public struct ID3D11VideoDeviceVtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* CreateVideoDecoder;

		public unsafe void* CreateVideoProcessor;

		public unsafe void* CreateAuthenticatedChannel;

		public unsafe void* CreateCryptoSession;

		public unsafe void* CreateVideoDecoderOutputView;

		public unsafe void* CreateVideoProcessorInputView;

		public unsafe void* CreateVideoProcessorOutputView;

		public unsafe void* CreateVideoProcessorEnumerator;

		public unsafe void* GetVideoDecoderProfileCount;

		public unsafe void* GetVideoDecoderProfile;

		public unsafe void* CheckVideoDecoderFormat;

		public unsafe void* GetVideoDecoderConfigCount;

		public unsafe void* GetVideoDecoderConfig;

		public unsafe void* GetContentProtectionCaps;

		public unsafe void* CheckCryptoKeyExchange;

		public unsafe void* SetPrivateData;

		public unsafe void* SetPrivateDataInterface;
	}
	public struct IDirect3DDeviceManager9
	{
		public unsafe IDirect3DDeviceManager9Vtbl* lpVtbl;
	}
	public struct IDirect3DDeviceManager9Vtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* ResetDevice;

		public unsafe void* OpenDeviceHandle;

		public unsafe void* CloseDeviceHandle;

		public unsafe void* TestDevice;

		public unsafe void* LockDevice;

		public unsafe void* UnlockDevice;

		public unsafe void* GetVideoService;
	}
	public struct IDirect3DSurface9
	{
		public unsafe IDirect3DSurface9Vtbl* lpVtbl;
	}
	public struct IDirect3DSurface9Vtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* GetDevice;

		public unsafe void* SetPrivateData;

		public unsafe void* GetPrivateData;

		public unsafe void* FreePrivateData;

		public unsafe void* SetPriority;

		public unsafe void* GetPriority;

		public unsafe void* PreLoad;

		public new unsafe void* GetType;

		public unsafe void* GetContainer;

		public unsafe void* GetDesc;

		public unsafe void* LockRect;

		public unsafe void* UnlockRect;

		public unsafe void* GetDC;

		public unsafe void* ReleaseDC;
	}
	public struct IDirectXVideoDecoder
	{
		public unsafe IDirectXVideoDecoderVtbl* lpVtbl;
	}
	public struct IDirectXVideoDecoderVtbl
	{
		public unsafe void* QueryInterface;

		public unsafe void* AddRef;

		public unsafe void* Release;

		public unsafe void* GetVideoDecoderService;

		public unsafe void* GetCreationParameters;

		public unsafe void* GetBuffer;

		public unsafe void* ReleaseBuffer;

		public unsafe void* BeginFrame;

		public unsafe void* EndFrame;

		public unsafe void* Execute;
	}
	public struct RcOverride
	{
		public int start_frame;

		public int end_frame;

		public int qscale;

		public float quality_factor;
	}
	public struct SwsContext
	{
		public unsafe AVClass* av_class;

		public unsafe void* opaque;

		public uint flags;

		public double_array2 scaler_params;

		public int threads;

		public SwsDither dither;

		public SwsAlphaBlend alpha_blend;

		public int gamma_flag;

		public int src_w;

		public int src_h;

		public int dst_w;

		public int dst_h;

		public int src_format;

		public int dst_format;

		public int src_range;

		public int dst_range;

		public int src_v_chr_pos;

		public int src_h_chr_pos;

		public int dst_v_chr_pos;

		public int dst_h_chr_pos;

		public int intent;
	}
	public struct SwsFilter
	{
		public unsafe SwsVector* lumH;

		public unsafe SwsVector* lumV;

		public unsafe SwsVector* chrH;

		public unsafe SwsVector* chrV;
	}
	public struct SwsVector
	{
		public unsafe double* coeff;

		public int length;
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVAudioFifo
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVBPrint
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVBSFList
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVBuffer
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVBufferPool
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVCodecInternal
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVCodecTag
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVContainerFifo
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVDictionary
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVFilterChannelLayouts
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVFilterCommand
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVFilterFormats
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVFilterPad
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVIAMFAudioElement
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVIAMFMixPresentation
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVIODirContext
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct AVTreeNode
	{
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct SwrContext
	{
	}
	public static class vectors
	{
		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_add_index_entry_delegate(AVStream* st, long pos, long timestamp, int size, int distance, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVRational av_add_q_delegate(AVRational b, AVRational c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_add_stable_delegate(AVRational ts_tb, long ts, AVRational inc_tb, long inc);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_append_packet_delegate(AVIOContext* s, AVPacket* pkt, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVAudioFifo* av_audio_fifo_alloc_delegate(AVSampleFormat sample_fmt, int channels, int nb_samples);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_audio_fifo_drain_delegate(AVAudioFifo* af, int nb_samples);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_audio_fifo_free_delegate(AVAudioFifo* af);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_audio_fifo_peek_delegate(AVAudioFifo* af, void** data, int nb_samples);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_audio_fifo_peek_at_delegate(AVAudioFifo* af, void** data, int nb_samples, int offset);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_audio_fifo_read_delegate(AVAudioFifo* af, void** data, int nb_samples);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_audio_fifo_realloc_delegate(AVAudioFifo* af, int nb_samples);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_audio_fifo_reset_delegate(AVAudioFifo* af);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_audio_fifo_size_delegate(AVAudioFifo* af);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_audio_fifo_space_delegate(AVAudioFifo* af);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_audio_fifo_write_delegate(AVAudioFifo* af, void** data, int nb_samples);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate double av_bessel_i0_delegate(double x);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_alloc_delegate(AVBitStreamFilter* filter, AVBSFContext** ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_bsf_flush_delegate(AVBSFContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_bsf_free_delegate(AVBSFContext** ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBitStreamFilter* av_bsf_get_by_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* av_bsf_get_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_get_null_filter_delegate(AVBSFContext** bsf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_init_delegate(AVBSFContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBitStreamFilter* av_bsf_iterate_delegate(void** opaque);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBSFList* av_bsf_list_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_list_append_delegate(AVBSFList* lst, AVBSFContext* bsf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_list_append2_delegate(AVBSFList* lst, [MarshalAs(UnmanagedType.LPUTF8Str)] string bsf_name, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_list_finalize_delegate(AVBSFList** lst, AVBSFContext** bsf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_bsf_list_free_delegate(AVBSFList** lst);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_list_parse_str_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string str, AVBSFContext** bsf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_receive_packet_delegate(AVBSFContext* ctx, AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_bsf_send_packet_delegate(AVBSFContext* ctx, AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_buffer_alloc_delegate(ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_buffer_allocz_delegate(ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_buffer_create_delegate(byte* data, ulong size, av_buffer_create_free_func free, void* opaque, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_buffer_default_free_delegate(void* opaque, byte* data);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_buffer_get_opaque_delegate(AVBufferRef* buf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffer_get_ref_count_delegate(AVBufferRef* buf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffer_is_writable_delegate(AVBufferRef* buf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffer_make_writable_delegate(AVBufferRef** buf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_buffer_pool_buffer_get_opaque_delegate(AVBufferRef* @ref);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_buffer_pool_get_delegate(AVBufferPool* pool);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferPool* av_buffer_pool_init_delegate(ulong size, av_buffer_pool_init_alloc_func alloc);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferPool* av_buffer_pool_init2_delegate(ulong size, void* opaque, av_buffer_pool_init2_alloc_func alloc, av_buffer_pool_init2_pool_free_func pool_free);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_buffer_pool_uninit_delegate(AVBufferPool** pool);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffer_realloc_delegate(AVBufferRef** buf, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_buffer_ref_delegate(AVBufferRef* buf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffer_replace_delegate(AVBufferRef** dst, AVBufferRef* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_buffer_unref_delegate(AVBufferRef** buf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_ch_layout_delegate(AVFilterContext* ctx, AVChannelLayout* ch_layout);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_channels_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVColorRange av_buffersink_get_color_range_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVColorSpace av_buffersink_get_colorspace_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_format_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_frame_delegate(AVFilterContext* ctx, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_frame_flags_delegate(AVFilterContext* ctx, AVFrame* frame, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVRational av_buffersink_get_frame_rate_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_h_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_buffersink_get_hw_frames_ctx_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVRational av_buffersink_get_sample_aspect_ratio_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_sample_rate_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_samples_delegate(AVFilterContext* ctx, AVFrame* frame, int nb_samples);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrameSideData** av_buffersink_get_side_data_delegate(AVFilterContext* ctx, int* nb_side_data);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVRational av_buffersink_get_time_base_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVMediaType av_buffersink_get_type_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersink_get_w_delegate(AVFilterContext* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_buffersink_set_frame_size_delegate(AVFilterContext* ctx, uint frame_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersrc_add_frame_delegate(AVFilterContext* ctx, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersrc_add_frame_flags_delegate(AVFilterContext* buffer_src, AVFrame* frame, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersrc_close_delegate(AVFilterContext* ctx, long pts, uint flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint av_buffersrc_get_nb_failed_requests_delegate(AVFilterContext* buffer_src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferSrcParameters* av_buffersrc_parameters_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersrc_parameters_set_delegate(AVFilterContext* ctx, AVBufferSrcParameters* param);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_buffersrc_write_frame_delegate(AVFilterContext* ctx, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_calloc_delegate(ulong nmemb, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_description_delegate(byte* buf, ulong buf_size, AVChannel channel);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_channel_description_bprint_delegate(AVBPrint* bp, AVChannel channel_id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVChannel av_channel_from_string_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_ambisonic_order_delegate(AVChannelLayout* channel_layout);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVChannel av_channel_layout_channel_from_index_delegate(AVChannelLayout* channel_layout, uint idx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVChannel av_channel_layout_channel_from_string_delegate(AVChannelLayout* channel_layout, [MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_check_delegate(AVChannelLayout* channel_layout);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_compare_delegate(AVChannelLayout* chl, AVChannelLayout* chl1);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_copy_delegate(AVChannelLayout* dst, AVChannelLayout* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_custom_init_delegate(AVChannelLayout* channel_layout, int nb_channels);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_channel_layout_default_delegate(AVChannelLayout* ch_layout, int nb_channels);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_describe_delegate(AVChannelLayout* channel_layout, byte* buf, ulong buf_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_describe_bprint_delegate(AVChannelLayout* channel_layout, AVBPrint* bp);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_from_mask_delegate(AVChannelLayout* channel_layout, ulong mask);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_from_string_delegate(AVChannelLayout* channel_layout, [MarshalAs(UnmanagedType.LPUTF8Str)] string str);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_index_from_channel_delegate(AVChannelLayout* channel_layout, AVChannel channel);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_index_from_string_delegate(AVChannelLayout* channel_layout, [MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_layout_retype_delegate(AVChannelLayout* channel_layout, AVChannelOrder order, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVChannelLayout* av_channel_layout_standard_delegate(void** opaque);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate ulong av_channel_layout_subset_delegate(AVChannelLayout* channel_layout, ulong mask);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_channel_layout_uninit_delegate(AVChannelLayout* channel_layout);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_channel_name_delegate(byte* buf, ulong buf_size, AVChannel channel);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_channel_name_bprint_delegate(AVBPrint* bp, AVChannel channel_id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_chroma_location_enum_to_pos_delegate(int* xpos, int* ypos, AVChromaLocation pos);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_chroma_location_from_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_chroma_location_name_delegate(AVChromaLocation location);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVChromaLocation av_chroma_location_pos_to_enum_delegate(int xpos, int ypos);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecID av_codec_get_id_delegate(AVCodecTag** tags, uint tag);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint av_codec_get_tag_delegate(AVCodecTag** tags, AVCodecID id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_codec_get_tag2_delegate(AVCodecTag** tags, AVCodecID id, uint* tag);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_codec_is_decoder_delegate(AVCodec* codec);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_codec_is_encoder_delegate(AVCodec* codec);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodec* av_codec_iterate_delegate(void** opaque);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_color_primaries_from_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_color_primaries_name_delegate(AVColorPrimaries primaries);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_color_range_from_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_color_range_name_delegate(AVColorRange range);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_color_space_from_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_color_space_name_delegate(AVColorSpace space);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_color_transfer_from_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_color_transfer_name_delegate(AVColorTransferCharacteristic transfer);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_compare_mod_delegate(ulong a, ulong b, ulong mod);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_compare_ts_delegate(long ts_a, AVRational tb_a, long ts_b, AVRational tb_b);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVContainerFifo* av_container_fifo_alloc_avpacket_delegate(uint flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVContentLightMetadata* av_content_light_metadata_alloc_delegate(ulong* size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVContentLightMetadata* av_content_light_metadata_create_side_data_delegate(AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCPBProperties* av_cpb_properties_alloc_delegate(ulong* size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_cpu_count_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_cpu_force_count_delegate(int count);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate ulong av_cpu_max_align_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVRational av_d2q_delegate(double d, int max);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVD3D11VAContext* av_d3d11va_alloc_context_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClassCategory av_default_get_category_delegate(void* ptr);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public unsafe delegate string av_default_item_name_delegate(void* ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVInputFormat* av_demuxer_iterate_delegate(void** opaque);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dict_copy_delegate(AVDictionary** dst, AVDictionary* src, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dict_count_delegate(AVDictionary* m);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_dict_free_delegate(AVDictionary** m);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVDictionaryEntry* av_dict_get_delegate(AVDictionary* m, [MarshalAs(UnmanagedType.LPUTF8Str)] string key, AVDictionaryEntry* prev, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dict_get_string_delegate(AVDictionary* m, byte** buffer, byte key_val_sep, byte pairs_sep);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVDictionaryEntry* av_dict_iterate_delegate(AVDictionary* m, AVDictionaryEntry* prev);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dict_parse_string_delegate(AVDictionary** pm, [MarshalAs(UnmanagedType.LPUTF8Str)] string str, [MarshalAs(UnmanagedType.LPUTF8Str)] string key_val_sep, [MarshalAs(UnmanagedType.LPUTF8Str)] string pairs_sep, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dict_set_delegate(AVDictionary** pm, [MarshalAs(UnmanagedType.LPUTF8Str)] string key, [MarshalAs(UnmanagedType.LPUTF8Str)] string value, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dict_set_int_delegate(AVDictionary** pm, [MarshalAs(UnmanagedType.LPUTF8Str)] string key, long value, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_display_matrix_flip_delegate(ref int_array9 matrix, int hflip, int vflip);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate double av_display_rotation_get_delegate(in int_array9 matrix);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_display_rotation_set_delegate(ref int_array9 matrix, double angle);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_disposition_from_string_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string disp);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_disposition_to_string_delegate(int disposition);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVRational av_div_q_delegate(AVRational b, AVRational c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_dump_format_delegate(AVFormatContext* ic, int index, [MarshalAs(UnmanagedType.LPUTF8Str)] string url, int is_output);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVDynamicHDRPlus* av_dynamic_hdr_plus_alloc_delegate(ulong* size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVDynamicHDRPlus* av_dynamic_hdr_plus_create_side_data_delegate(AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dynamic_hdr_plus_from_t35_delegate(AVDynamicHDRPlus* s, byte* data, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dynamic_hdr_plus_to_t35_delegate(AVDynamicHDRPlus* s, byte** data, ulong* size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_dynarray_add_delegate(void* tab_ptr, int* nb_ptr, void* elem);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_dynarray_add_nofree_delegate(void* tab_ptr, int* nb_ptr, void* elem);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_dynarray2_add_delegate(void** tab_ptr, int* nb_ptr, ulong elem_size, byte* elem_data);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_fast_malloc_delegate(void* ptr, uint* size, ulong min_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_fast_mallocz_delegate(void* ptr, uint* size, ulong min_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_fast_padded_malloc_delegate(void* ptr, uint* size, ulong min_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_fast_padded_mallocz_delegate(void* ptr, uint* size, ulong min_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_fast_realloc_delegate(void* ptr, uint* size, ulong min_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_file_map_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string filename, byte** bufptr, ulong* size, int log_offset, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_file_unmap_delegate(byte* bufptr, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_filename_number_test_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string filename);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFilter* av_filter_iterate_delegate(void** opaque);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPixelFormat av_find_best_pix_fmt_of_2_delegate(AVPixelFormat dst_pix_fmt1, AVPixelFormat dst_pix_fmt2, AVPixelFormat src_pix_fmt, int has_alpha, int* loss_ptr);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_find_best_stream_delegate(AVFormatContext* ic, AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec** decoder_ret, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_find_default_stream_index_delegate(AVFormatContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVInputFormat* av_find_input_format_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string short_name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_find_nearest_q_idx_delegate(AVRational q, AVRational* q_list);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVProgram* av_find_program_from_stream_delegate(AVFormatContext* ic, AVProgram* last, int s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_force_cpu_flags_delegate(int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_fourcc_make_string_delegate(byte* buf, uint fourcc);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrame* av_frame_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_apply_cropping_delegate(AVFrame* frame, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrame* av_frame_clone_delegate(AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_copy_delegate(AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_copy_props_delegate(AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_frame_free_delegate(AVFrame** frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_get_buffer_delegate(AVFrame* frame, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_frame_get_plane_buffer_delegate(AVFrame* frame, int plane);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrameSideData* av_frame_get_side_data_delegate(AVFrame* frame, AVFrameSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_is_writable_delegate(AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_make_writable_delegate(AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_frame_move_ref_delegate(AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrameSideData* av_frame_new_side_data_delegate(AVFrame* frame, AVFrameSideDataType type, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrameSideData* av_frame_new_side_data_from_buf_delegate(AVFrame* frame, AVFrameSideDataType type, AVBufferRef* buf);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_ref_delegate(AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_frame_remove_side_data_delegate(AVFrame* frame, AVFrameSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_replace_delegate(AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrameSideData* av_frame_side_data_add_delegate(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type, AVBufferRef** buf, uint flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_frame_side_data_clone_delegate(AVFrameSideData*** sd, int* nb_sd, AVFrameSideData* src, uint flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVSideDataDescriptor* av_frame_side_data_desc_delegate(AVFrameSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_frame_side_data_free_delegate(AVFrameSideData*** sd, int* nb_sd);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrameSideData* av_frame_side_data_get_c_delegate(AVFrameSideData** sd, int nb_sd, AVFrameSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_frame_side_data_name_delegate(AVFrameSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFrameSideData* av_frame_side_data_new_delegate(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type, ulong size, uint flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_frame_side_data_remove_delegate(AVFrameSideData*** sd, int* nb_sd, AVFrameSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_frame_side_data_remove_by_props_delegate(AVFrameSideData*** sd, int* nb_sd, int props);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_frame_unref_delegate(AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_free_delegate(void* ptr);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_freep_delegate(void* ptr);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_gcd_delegate(long a, long b);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVRational av_gcd_q_delegate(AVRational a, AVRational b, int max_den, AVRational def);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVSampleFormat av_get_alt_sample_fmt_delegate(AVSampleFormat sample_fmt, int planar);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_get_audio_frame_duration_delegate(AVCodecContext* avctx, int frame_bytes);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_get_audio_frame_duration2_delegate(AVCodecParameters* par, int frame_bytes);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_get_bits_per_pixel_delegate(AVPixFmtDescriptor* pixdesc);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_get_bits_per_sample_delegate(AVCodecID codec_id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_get_bytes_per_sample_delegate(AVSampleFormat sample_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_get_cpu_flags_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_get_exact_bits_per_sample_delegate(AVCodecID codec_id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_get_frame_filename_delegate(byte* buf, int buf_size, [MarshalAs(UnmanagedType.LPUTF8Str)] string path, int number);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_get_frame_filename2_delegate(byte* buf, int buf_size, [MarshalAs(UnmanagedType.LPUTF8Str)] string path, int number, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_get_media_type_string_delegate(AVMediaType media_type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_get_output_timestamp_delegate(AVFormatContext* s, int stream, long* dts, long* wall);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVSampleFormat av_get_packed_sample_fmt_delegate(AVSampleFormat sample_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_get_packet_delegate(AVIOContext* s, AVPacket* pkt, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_get_padded_bits_per_pixel_delegate(AVPixFmtDescriptor* pixdesc);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVCodecID av_get_pcm_codec_delegate(AVSampleFormat fmt, int be);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate byte av_get_picture_type_char_delegate(AVPictureType pict_type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVPixelFormat av_get_pix_fmt_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_get_pix_fmt_loss_delegate(AVPixelFormat dst_pix_fmt, AVPixelFormat src_pix_fmt, int has_alpha);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_get_pix_fmt_name_delegate(AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_get_pix_fmt_string_delegate(byte* buf, int buf_size, AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVSampleFormat av_get_planar_sample_fmt_delegate(AVSampleFormat sample_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public unsafe delegate string av_get_profile_name_delegate(AVCodec* codec, int profile);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVSampleFormat av_get_sample_fmt_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_get_sample_fmt_name_delegate(AVSampleFormat sample_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_get_sample_fmt_string_delegate(byte* buf, int buf_size, AVSampleFormat sample_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVRational av_get_time_base_q_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_gettime_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_gettime_relative_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_gettime_relative_is_monotonic_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_grow_packet_delegate(AVPacket* pkt, int grow_by);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecID av_guess_codec_delegate(AVOutputFormat* fmt, [MarshalAs(UnmanagedType.LPUTF8Str)] string short_name, [MarshalAs(UnmanagedType.LPUTF8Str)] string filename, [MarshalAs(UnmanagedType.LPUTF8Str)] string mime_type, AVMediaType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVOutputFormat* av_guess_format_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string short_name, [MarshalAs(UnmanagedType.LPUTF8Str)] string filename, [MarshalAs(UnmanagedType.LPUTF8Str)] string mime_type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVRational av_guess_frame_rate_delegate(AVFormatContext* ctx, AVStream* stream, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVRational av_guess_sample_aspect_ratio_delegate(AVFormatContext* format, AVStream* stream, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_hex_dump_delegate(_iobuf* f, byte* buf, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_hex_dump_log_delegate(void* avcl, int level, byte* buf, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_hwdevice_ctx_alloc_delegate(AVHWDeviceType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwdevice_ctx_create_delegate(AVBufferRef** device_ctx, AVHWDeviceType type, [MarshalAs(UnmanagedType.LPUTF8Str)] string device, AVDictionary* opts, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwdevice_ctx_create_derived_delegate(AVBufferRef** dst_ctx, AVHWDeviceType type, AVBufferRef* src_ctx, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwdevice_ctx_create_derived_opts_delegate(AVBufferRef** dst_ctx, AVHWDeviceType type, AVBufferRef* src_ctx, AVDictionary* options, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwdevice_ctx_init_delegate(AVBufferRef* @ref);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVHWDeviceType av_hwdevice_find_type_by_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVHWFramesConstraints* av_hwdevice_get_hwframe_constraints_delegate(AVBufferRef* @ref, void* hwconfig);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_hwdevice_get_type_name_delegate(AVHWDeviceType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_hwdevice_hwconfig_alloc_delegate(AVBufferRef* device_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVHWDeviceType av_hwdevice_iterate_types_delegate(AVHWDeviceType prev);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_hwframe_constraints_free_delegate(AVHWFramesConstraints** constraints);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* av_hwframe_ctx_alloc_delegate(AVBufferRef* device_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwframe_ctx_create_derived_delegate(AVBufferRef** derived_frame_ctx, AVPixelFormat format, AVBufferRef* derived_device_ctx, AVBufferRef* source_frame_ctx, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwframe_ctx_init_delegate(AVBufferRef* @ref);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwframe_get_buffer_delegate(AVBufferRef* hwframe_ctx, AVFrame* frame, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwframe_map_delegate(AVFrame* dst, AVFrame* src, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwframe_transfer_data_delegate(AVFrame* dst, AVFrame* src, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_hwframe_transfer_get_formats_delegate(AVBufferRef* hwframe_ctx, AVHWFrameTransferDirection dir, AVPixelFormat** formats, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_image_alloc_delegate(ref byte_ptrArray4 pointers, ref int_array4 linesizes, int w, int h, AVPixelFormat pix_fmt, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_image_check_sar_delegate(uint w, uint h, AVRational sar);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_image_check_size_delegate(uint w, uint h, int log_offset, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_image_check_size2_delegate(uint w, uint h, long max_pixels, AVPixelFormat pix_fmt, int log_offset, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_image_copy_delegate(ref byte_ptrArray4 dst_data, in int_array4 dst_linesizes, in byte_ptrArray4 src_data, in int_array4 src_linesizes, AVPixelFormat pix_fmt, int width, int height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_image_copy_plane_delegate(byte* dst, int dst_linesize, byte* src, int src_linesize, int bytewidth, int height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_image_copy_plane_uc_from_delegate(byte* dst, long dst_linesize, byte* src, long src_linesize, long bytewidth, int height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_image_copy_to_buffer_delegate(byte* dst, int dst_size, in byte_ptrArray4 src_data, in int_array4 src_linesize, AVPixelFormat pix_fmt, int width, int height, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_image_copy_uc_from_delegate(ref byte_ptrArray4 dst_data, in long_array4 dst_linesizes, in byte_ptrArray4 src_data, in long_array4 src_linesizes, AVPixelFormat pix_fmt, int width, int height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_image_fill_arrays_delegate(ref byte_ptrArray4 dst_data, ref int_array4 dst_linesize, byte* src, AVPixelFormat pix_fmt, int width, int height, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_image_fill_black_delegate(ref byte_ptrArray4 dst_data, in long_array4 dst_linesize, AVPixelFormat pix_fmt, AVColorRange range, int width, int height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_image_fill_color_delegate(ref byte_ptrArray4 dst_data, in long_array4 dst_linesize, AVPixelFormat pix_fmt, in uint_array4 color, int width, int height, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_image_fill_linesizes_delegate(ref int_array4 linesizes, AVPixelFormat pix_fmt, int width);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_image_fill_max_pixsteps_delegate(ref int_array4 max_pixsteps, ref int_array4 max_pixstep_comps, AVPixFmtDescriptor* pixdesc);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_image_fill_plane_sizes_delegate(ref ulong_array4 size, AVPixelFormat pix_fmt, int height, in long_array4 linesizes);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_image_fill_pointers_delegate(ref byte_ptrArray4 data, AVPixelFormat pix_fmt, int height, byte* ptr, in int_array4 linesizes);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_image_get_buffer_size_delegate(AVPixelFormat pix_fmt, int width, int height, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_image_get_linesize_delegate(AVPixelFormat pix_fmt, int width, int plane);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_index_search_timestamp_delegate(AVStream* st, long timestamp, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_init_packet_delegate(AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVInputFormat* av_input_audio_device_next_delegate(AVInputFormat* d);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVInputFormat* av_input_video_device_next_delegate(AVInputFormat* d);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint av_int_list_length_for_size_delegate(uint elsize, void* list, ulong term);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_interleaved_write_frame_delegate(AVFormatContext* s, AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_interleaved_write_uncoded_frame_delegate(AVFormatContext* s, int stream_index, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_log_delegate(void* avcl, int level, [MarshalAs(UnmanagedType.LPUTF8Str)] string fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_log_default_callback_delegate(void* avcl, int level, [MarshalAs(UnmanagedType.LPUTF8Str)] string fmt, byte* vl);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_log_format_line_delegate(void* ptr, int level, [MarshalAs(UnmanagedType.LPUTF8Str)] string fmt, byte* vl, byte* line, int line_size, int* print_prefix);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_log_format_line2_delegate(void* ptr, int level, [MarshalAs(UnmanagedType.LPUTF8Str)] string fmt, byte* vl, byte* line, int line_size, int* print_prefix);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_log_get_flags_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_log_get_level_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_log_once_delegate(void* avcl, int initial_level, int subsequent_level, int* state, [MarshalAs(UnmanagedType.LPUTF8Str)] string fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_log_set_callback_delegate(av_log_set_callback_callback_func callback);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_log_set_flags_delegate(int arg);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_log_set_level_delegate(int level);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_log2_delegate(uint v);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_log2_16bit_delegate(uint v);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_malloc_delegate(ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_malloc_array_delegate(ulong nmemb, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_mallocz_delegate(ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVMasteringDisplayMetadata* av_mastering_display_metadata_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVMasteringDisplayMetadata* av_mastering_display_metadata_alloc_size_delegate(ulong* size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVMasteringDisplayMetadata* av_mastering_display_metadata_create_side_data_delegate(AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_match_ext_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string filename, [MarshalAs(UnmanagedType.LPUTF8Str)] string extensions);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void av_max_alloc_delegate(ulong max);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_memcpy_backptr_delegate(byte* dst, int back, int cnt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_memdup_delegate(void* p, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVRational av_mul_q_delegate(AVRational b, AVRational c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVOutputFormat* av_muxer_iterate_delegate(void** opaque);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_nearer_q_delegate(AVRational q, AVRational q1, AVRational q2);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_new_packet_delegate(AVPacket* pkt, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVProgram* av_new_program_delegate(AVFormatContext* s, int id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* av_opt_child_class_iterate_delegate(AVClass* parent, void** iter);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_opt_child_next_delegate(void* obj, void* prev);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_copy_delegate(void* dest, void* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_eval_double_delegate(void* obj, AVOption* o, [MarshalAs(UnmanagedType.LPUTF8Str)] string val, double* double_out);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_eval_flags_delegate(void* obj, AVOption* o, [MarshalAs(UnmanagedType.LPUTF8Str)] string val, int* flags_out);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_eval_float_delegate(void* obj, AVOption* o, [MarshalAs(UnmanagedType.LPUTF8Str)] string val, float* float_out);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_eval_int_delegate(void* obj, AVOption* o, [MarshalAs(UnmanagedType.LPUTF8Str)] string val, int* int_out);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_eval_int64_delegate(void* obj, AVOption* o, [MarshalAs(UnmanagedType.LPUTF8Str)] string val, long* int64_out);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_eval_q_delegate(void* obj, AVOption* o, [MarshalAs(UnmanagedType.LPUTF8Str)] string val, AVRational* q_out);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_eval_uint_delegate(void* obj, AVOption* o, [MarshalAs(UnmanagedType.LPUTF8Str)] string val, uint* uint_out);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVOption* av_opt_find_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, [MarshalAs(UnmanagedType.LPUTF8Str)] string unit, int opt_flags, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVOption* av_opt_find2_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, [MarshalAs(UnmanagedType.LPUTF8Str)] string unit, int opt_flags, int search_flags, void** target_obj);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_flag_is_set_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string field_name, [MarshalAs(UnmanagedType.LPUTF8Str)] string flag_name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_opt_free_delegate(void* obj);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_opt_freep_ranges_delegate(AVOptionRanges** ranges);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, byte** out_val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_array_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, uint start_elem, uint nb_elems, AVOptionType out_type, void* out_val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_array_size_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, uint* out_val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_chlayout_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, AVChannelLayout* layout);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_dict_val_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, AVDictionary** out_val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_double_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, double* out_val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_image_size_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, int* w_out, int* h_out);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_int_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, long* out_val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_key_value_delegate(byte** ropts, [MarshalAs(UnmanagedType.LPUTF8Str)] string key_val_sep, [MarshalAs(UnmanagedType.LPUTF8Str)] string pairs_sep, uint flags, byte** rkey, byte** rval);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_pixel_fmt_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, AVPixelFormat* out_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_q_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, AVRational* out_val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_sample_fmt_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, AVSampleFormat* out_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_get_video_rate_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, AVRational* out_val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_is_set_to_default_delegate(void* obj, AVOption* o);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_is_set_to_default_by_name_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVOption* av_opt_next_delegate(void* obj, AVOption* prev);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_opt_ptr_delegate(AVClass* avclass, void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_query_ranges_delegate(AVOptionRanges** p0, void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string key, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_query_ranges_default_delegate(AVOptionRanges** p0, void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string key, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_serialize_delegate(void* obj, int opt_flags, int flags, byte** buffer, byte key_val_sep, byte pairs_sep);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, [MarshalAs(UnmanagedType.LPUTF8Str)] string val, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_array_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int search_flags, uint start_elem, uint nb_elems, AVOptionType val_type, void* val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_bin_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, byte* val, int size, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_chlayout_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, AVChannelLayout* layout, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_opt_set_defaults_delegate(void* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_opt_set_defaults2_delegate(void* s, int mask, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_dict_delegate(void* obj, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_dict_val_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, AVDictionary* val, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_dict2_delegate(void* obj, AVDictionary** options, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_double_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, double val, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_from_string_delegate(void* ctx, [MarshalAs(UnmanagedType.LPUTF8Str)] string opts, byte** shorthand, [MarshalAs(UnmanagedType.LPUTF8Str)] string key_val_sep, [MarshalAs(UnmanagedType.LPUTF8Str)] string pairs_sep);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_image_size_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, int w, int h, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_int_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, long val, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_pixel_fmt_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, AVPixelFormat fmt, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_q_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, AVRational val, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_sample_fmt_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, AVSampleFormat fmt, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_set_video_rate_delegate(void* obj, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, AVRational val, int search_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_opt_show2_delegate(void* obj, void* av_log_obj, int req_flags, int rej_flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVOutputFormat* av_output_audio_device_next_delegate(AVOutputFormat* d);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVOutputFormat* av_output_video_device_next_delegate(AVOutputFormat* d);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_packet_add_side_data_delegate(AVPacket* pkt, AVPacketSideDataType type, byte* data, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPacket* av_packet_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPacket* av_packet_clone_delegate(AVPacket* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_packet_copy_props_delegate(AVPacket* dst, AVPacket* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_packet_free_delegate(AVPacket** pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_packet_free_side_data_delegate(AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_packet_from_data_delegate(AVPacket* pkt, byte* data, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_packet_get_side_data_delegate(AVPacket* pkt, AVPacketSideDataType type, ulong* size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_packet_make_refcounted_delegate(AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_packet_make_writable_delegate(AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_packet_move_ref_delegate(AVPacket* dst, AVPacket* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_packet_new_side_data_delegate(AVPacket* pkt, AVPacketSideDataType type, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_packet_pack_dictionary_delegate(AVDictionary* dict, ulong* size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_packet_ref_delegate(AVPacket* dst, AVPacket* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_packet_rescale_ts_delegate(AVPacket* pkt, AVRational tb_src, AVRational tb_dst);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_packet_shrink_side_data_delegate(AVPacket* pkt, AVPacketSideDataType type, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPacketSideData* av_packet_side_data_add_delegate(AVPacketSideData** sd, int* nb_sd, AVPacketSideDataType type, void* data, ulong size, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_packet_side_data_free_delegate(AVPacketSideData** sd, int* nb_sd);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPacketSideData* av_packet_side_data_get_delegate(AVPacketSideData* sd, int nb_sd, AVPacketSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_packet_side_data_name_delegate(AVPacketSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPacketSideData* av_packet_side_data_new_delegate(AVPacketSideData** psd, int* pnb_sd, AVPacketSideDataType type, ulong size, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_packet_side_data_remove_delegate(AVPacketSideData* sd, int* nb_sd, AVPacketSideDataType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_packet_unpack_dictionary_delegate(byte* data, ulong size, AVDictionary** dict);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_packet_unref_delegate(AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_parse_cpu_caps_delegate(uint* flags, [MarshalAs(UnmanagedType.LPUTF8Str)] string s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_parser_close_delegate(AVCodecParserContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecParserContext* av_parser_init_delegate(int codec_id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecParser* av_parser_iterate_delegate(void** opaque);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_parser_parse2_delegate(AVCodecParserContext* s, AVCodecContext* avctx, byte** poutbuf, int* poutbuf_size, byte* buf, int buf_size, long pts, long dts, long pos);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_pix_fmt_count_planes_delegate(AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPixFmtDescriptor* av_pix_fmt_desc_get_delegate(AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPixelFormat av_pix_fmt_desc_get_id_delegate(AVPixFmtDescriptor* desc);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPixFmtDescriptor* av_pix_fmt_desc_next_delegate(AVPixFmtDescriptor* prev);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_pix_fmt_get_chroma_sub_sample_delegate(AVPixelFormat pix_fmt, int* h_shift, int* v_shift);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVPixelFormat av_pix_fmt_swap_endianness_delegate(AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_pkt_dump_log2_delegate(void* avcl, int level, AVPacket* pkt, int dump_payload, AVStream* st);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_pkt_dump2_delegate(_iobuf* f, AVPacket* pkt, int dump_payload, AVStream* st);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_probe_input_buffer_delegate(AVIOContext* pb, AVInputFormat** fmt, [MarshalAs(UnmanagedType.LPUTF8Str)] string url, void* logctx, uint offset, uint max_probe_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_probe_input_buffer2_delegate(AVIOContext* pb, AVInputFormat** fmt, [MarshalAs(UnmanagedType.LPUTF8Str)] string url, void* logctx, uint offset, uint max_probe_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVInputFormat* av_probe_input_format_delegate(AVProbeData* pd, int is_opened);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVInputFormat* av_probe_input_format2_delegate(AVProbeData* pd, int is_opened, int* score_max);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVInputFormat* av_probe_input_format3_delegate(AVProbeData* pd, int is_opened, int* score_ret);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_program_add_stream_index_delegate(AVFormatContext* ac, int progid, uint idx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint av_q2intfloat_delegate(AVRational q);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_read_frame_delegate(AVFormatContext* s, AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_read_image_line_delegate(ushort* dst, in byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int read_pal_component);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_read_image_line2_delegate(void* dst, in byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int read_pal_component, int dst_element_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_read_pause_delegate(AVFormatContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_read_play_delegate(AVFormatContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_realloc_delegate(void* ptr, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_realloc_array_delegate(void* ptr, ulong nmemb, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_realloc_f_delegate(void* ptr, ulong nelem, ulong elsize);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_reallocp_delegate(void* ptr, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_reallocp_array_delegate(void* ptr, ulong nmemb, ulong size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_reduce_delegate(int* dst_num, int* dst_den, long num, long den, long max);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_rescale_delegate(long a, long b, long c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate long av_rescale_delta_delegate(AVRational in_tb, long in_ts, AVRational fs_tb, int duration, long* last, AVRational out_tb);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_rescale_q_delegate(long a, AVRational bq, AVRational cq);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_rescale_q_rnd_delegate(long a, AVRational bq, AVRational cq, AVRounding rnd);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate long av_rescale_rnd_delegate(long a, long b, long c, AVRounding rnd);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_sample_fmt_is_planar_delegate(AVSampleFormat sample_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_samples_alloc_delegate(byte** audio_data, int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_samples_alloc_array_and_samples_delegate(byte*** audio_data, int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_samples_copy_delegate(byte** dst, byte** src, int dst_offset, int src_offset, int nb_samples, int nb_channels, AVSampleFormat sample_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_samples_fill_arrays_delegate(byte** audio_data, int* linesize, byte* buf, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_samples_get_buffer_size_delegate(int* linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_samples_set_silence_delegate(byte** audio_data, int offset, int nb_samples, int nb_channels, AVSampleFormat sample_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_sdp_create_delegate(AVFormatContext** ac, int n_files, byte* buf, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_seek_frame_delegate(AVFormatContext* s, int stream_index, long timestamp, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_set_options_string_delegate(void* ctx, [MarshalAs(UnmanagedType.LPUTF8Str)] string opts, [MarshalAs(UnmanagedType.LPUTF8Str)] string key_val_sep, [MarshalAs(UnmanagedType.LPUTF8Str)] string pairs_sep);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_shrink_packet_delegate(AVPacket* pkt, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_size_mult_delegate(ulong a, ulong b, ulong* r);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_strdup_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* av_stream_get_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVRational av_stream_get_codec_timebase_delegate(AVStream* st);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecParserContext* av_stream_get_parser_delegate(AVStream* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* av_stream_group_get_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_strerror_delegate(int errnum, byte* errbuf, ulong errbuf_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_strndup_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string s, ulong len);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVRational av_sub_q_delegate(AVRational b, AVRational c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_timecode_adjust_ntsc_framenum2_delegate(int framenum, int fps);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_timecode_check_frame_rate_delegate(AVRational rate);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint av_timecode_get_smpte_delegate(AVRational rate, int drop, int hh, int mm, int ss, int ff);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint av_timecode_get_smpte_from_framenum_delegate(AVTimecode* tc, int framenum);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_timecode_init_delegate(AVTimecode* tc, AVRational rate, int flags, int frame_start, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_timecode_init_from_components_delegate(AVTimecode* tc, AVRational rate, int flags, int hh, int mm, int ss, int ff, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_timecode_init_from_string_delegate(AVTimecode* tc, AVRational rate, [MarshalAs(UnmanagedType.LPUTF8Str)] string str, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_timecode_make_mpeg_tc_string_delegate(byte* buf, uint tc25bit);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_timecode_make_smpte_tc_string_delegate(byte* buf, uint tcsmpte, int prevent_df);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_timecode_make_smpte_tc_string2_delegate(byte* buf, AVRational rate, uint tcsmpte, int prevent_df, int skip_field);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* av_timecode_make_string_delegate(AVTimecode* tc, byte* buf, int framenum);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_tree_destroy_delegate(AVTreeNode* t);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_tree_enumerate_delegate(AVTreeNode* t, void* opaque, av_tree_enumerate_cmp_func cmp, av_tree_enumerate_enu_func enu);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_tree_find_delegate(AVTreeNode* root, void* key, av_tree_find_cmp_func cmp, ref void_ptrArray2 next);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void* av_tree_insert_delegate(AVTreeNode** rootp, void* key, av_tree_insert_cmp_func cmp, AVTreeNode** next);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVTreeNode* av_tree_node_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_url_split_delegate(byte* proto, int proto_size, byte* authorization, int authorization_size, byte* hostname, int hostname_size, int* port_ptr, byte* path, int path_size, [MarshalAs(UnmanagedType.LPUTF8Str)] string url);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int av_usleep_delegate(uint usec);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string av_version_info_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_vlog_delegate(void* avcl, int level, [MarshalAs(UnmanagedType.LPUTF8Str)] string fmt, byte* vl);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_write_frame_delegate(AVFormatContext* s, AVPacket* pkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_write_image_line_delegate(ushort* src, ref byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void av_write_image_line2_delegate(void* src, ref byte_ptrArray4 data, in int_array4 linesize, AVPixFmtDescriptor* desc, int x, int y, int c, int w, int src_element_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_write_trailer_delegate(AVFormatContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_write_uncoded_frame_delegate(AVFormatContext* s, int stream_index, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int av_write_uncoded_frame_query_delegate(AVFormatContext* s, int stream_index);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint av_xiphlacing_delegate(byte* s, uint v);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avcodec_align_dimensions_delegate(AVCodecContext* s, int* width, int* height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avcodec_align_dimensions2_delegate(AVCodecContext* s, int* width, int* height, ref int_array8 linesize_align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecContext* avcodec_alloc_context3_delegate(AVCodec* codec);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avcodec_configuration_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_decode_subtitle2_delegate(AVCodecContext* avctx, AVSubtitle* sub, int* got_sub_ptr, AVPacket* avpkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_default_execute_delegate(AVCodecContext* c, avcodec_default_execute_func_func func, void* arg, int* ret, int count, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_default_execute2_delegate(AVCodecContext* c, avcodec_default_execute2_func_func func, void* arg, int* ret, int count);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_default_get_buffer2_delegate(AVCodecContext* s, AVFrame* frame, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_default_get_encode_buffer_delegate(AVCodecContext* s, AVPacket* pkt, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPixelFormat avcodec_default_get_format_delegate(AVCodecContext* s, AVPixelFormat* fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecDescriptor* avcodec_descriptor_get_delegate(AVCodecID id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecDescriptor* avcodec_descriptor_get_by_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecDescriptor* avcodec_descriptor_next_delegate(AVCodecDescriptor* prev);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_encode_subtitle_delegate(AVCodecContext* avctx, byte* buf, int buf_size, AVSubtitle* sub);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_fill_audio_frame_delegate(AVFrame* frame, int nb_channels, AVSampleFormat sample_fmt, byte* buf, int buf_size, int align);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVPixelFormat avcodec_find_best_pix_fmt_of_list_delegate(AVPixelFormat* pix_fmt_list, AVPixelFormat src_pix_fmt, int has_alpha, int* loss_ptr);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodec* avcodec_find_decoder_delegate(AVCodecID id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodec* avcodec_find_decoder_by_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodec* avcodec_find_encoder_delegate(AVCodecID id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodec* avcodec_find_encoder_by_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avcodec_flush_buffers_delegate(AVCodecContext* avctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avcodec_free_context_delegate(AVCodecContext** avctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* avcodec_get_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecHWConfig* avcodec_get_hw_config_delegate(AVCodec* codec, int index);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_get_hw_frames_parameters_delegate(AVCodecContext* avctx, AVBufferRef* device_ref, AVPixelFormat hw_pix_fmt, AVBufferRef** out_frames_ref);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avcodec_get_name_delegate(AVCodecID id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* avcodec_get_subtitle_rect_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_get_supported_config_delegate(AVCodecContext* avctx, AVCodec* codec, AVCodecConfig config, uint flags, void** out_configs, int* out_num_configs);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate AVMediaType avcodec_get_type_delegate(AVCodecID codec_id);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_is_open_delegate(AVCodecContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avcodec_license_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_open2_delegate(AVCodecContext* avctx, AVCodec* codec, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecParameters* avcodec_parameters_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_parameters_copy_delegate(AVCodecParameters* dst, AVCodecParameters* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avcodec_parameters_free_delegate(AVCodecParameters** par);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_parameters_from_context_delegate(AVCodecParameters* par, AVCodecContext* codec);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_parameters_to_context_delegate(AVCodecContext* codec, AVCodecParameters* par);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint avcodec_pix_fmt_to_codec_tag_delegate(AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avcodec_profile_name_delegate(AVCodecID codec_id, int profile);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_receive_frame_delegate(AVCodecContext* avctx, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_receive_packet_delegate(AVCodecContext* avctx, AVPacket* avpkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_send_frame_delegate(AVCodecContext* avctx, AVFrame* frame);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avcodec_send_packet_delegate(AVCodecContext* avctx, AVPacket* avpkt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avcodec_string_delegate(byte* buf, int buf_size, AVCodecContext* enc, int encode);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint avcodec_version_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avdevice_app_to_dev_control_message_delegate(AVFormatContext* s, AVAppToDevMessageType type, void* data, ulong data_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avdevice_configuration_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avdevice_dev_to_app_control_message_delegate(AVFormatContext* s, AVDevToAppMessageType type, void* data, ulong data_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avdevice_free_list_devices_delegate(AVDeviceInfoList** device_list);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avdevice_license_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avdevice_list_devices_delegate(AVFormatContext* s, AVDeviceInfoList** device_list);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avdevice_list_input_sources_delegate(AVInputFormat* device, [MarshalAs(UnmanagedType.LPUTF8Str)] string device_name, AVDictionary* device_options, AVDeviceInfoList** device_list);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avdevice_list_output_sinks_delegate(AVOutputFormat* device, [MarshalAs(UnmanagedType.LPUTF8Str)] string device_name, AVDictionary* device_options, AVDeviceInfoList** device_list);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate void avdevice_register_all_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint avdevice_version_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avfilter_configuration_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint avfilter_filter_pad_count_delegate(AVFilter* filter, int is_output);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avfilter_free_delegate(AVFilterContext* filter);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFilter* avfilter_get_by_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* avfilter_get_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFilterGraph* avfilter_graph_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFilterContext* avfilter_graph_alloc_filter_delegate(AVFilterGraph* graph, AVFilter* filter, [MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_config_delegate(AVFilterGraph* graphctx, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_create_filter_delegate(AVFilterContext** filt_ctx, AVFilter* filt, [MarshalAs(UnmanagedType.LPUTF8Str)] string name, [MarshalAs(UnmanagedType.LPUTF8Str)] string args, void* opaque, AVFilterGraph* graph_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate byte* avfilter_graph_dump_delegate(AVFilterGraph* graph, [MarshalAs(UnmanagedType.LPUTF8Str)] string options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avfilter_graph_free_delegate(AVFilterGraph** graph);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFilterContext* avfilter_graph_get_filter_delegate(AVFilterGraph* graph, [MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_parse_delegate(AVFilterGraph* graph, [MarshalAs(UnmanagedType.LPUTF8Str)] string filters, AVFilterInOut* inputs, AVFilterInOut* outputs, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_parse_ptr_delegate(AVFilterGraph* graph, [MarshalAs(UnmanagedType.LPUTF8Str)] string filters, AVFilterInOut** inputs, AVFilterInOut** outputs, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_parse2_delegate(AVFilterGraph* graph, [MarshalAs(UnmanagedType.LPUTF8Str)] string filters, AVFilterInOut** inputs, AVFilterInOut** outputs);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_queue_command_delegate(AVFilterGraph* graph, [MarshalAs(UnmanagedType.LPUTF8Str)] string target, [MarshalAs(UnmanagedType.LPUTF8Str)] string cmd, [MarshalAs(UnmanagedType.LPUTF8Str)] string arg, int flags, double ts);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_request_oldest_delegate(AVFilterGraph* graph);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_segment_apply_delegate(AVFilterGraphSegment* seg, int flags, AVFilterInOut** inputs, AVFilterInOut** outputs);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_segment_apply_opts_delegate(AVFilterGraphSegment* seg, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_segment_create_filters_delegate(AVFilterGraphSegment* seg, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avfilter_graph_segment_free_delegate(AVFilterGraphSegment** seg);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_segment_init_delegate(AVFilterGraphSegment* seg, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_segment_link_delegate(AVFilterGraphSegment* seg, int flags, AVFilterInOut** inputs, AVFilterInOut** outputs);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_segment_parse_delegate(AVFilterGraph* graph, [MarshalAs(UnmanagedType.LPUTF8Str)] string graph_str, int flags, AVFilterGraphSegment** seg);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_graph_send_command_delegate(AVFilterGraph* graph, [MarshalAs(UnmanagedType.LPUTF8Str)] string target, [MarshalAs(UnmanagedType.LPUTF8Str)] string cmd, [MarshalAs(UnmanagedType.LPUTF8Str)] string arg, byte* res, int res_len, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avfilter_graph_set_auto_convert_delegate(AVFilterGraph* graph, uint flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_init_dict_delegate(AVFilterContext* ctx, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_init_str_delegate(AVFilterContext* ctx, [MarshalAs(UnmanagedType.LPUTF8Str)] string args);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFilterInOut* avfilter_inout_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avfilter_inout_free_delegate(AVFilterInOut** inout);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_insert_filter_delegate(AVFilterLink* link, AVFilterContext* filt, uint filt_srcpad_idx, uint filt_dstpad_idx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avfilter_license_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_link_delegate(AVFilterContext* src, uint srcpad, AVFilterContext* dst, uint dstpad);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVBufferRef* avfilter_link_get_hw_frames_ctx_delegate(AVFilterLink* link);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public unsafe delegate string avfilter_pad_get_name_delegate(AVFilterPad* pads, int pad_idx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVMediaType avfilter_pad_get_type_delegate(AVFilterPad* pads, int pad_idx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avfilter_process_command_delegate(AVFilterContext* filter, [MarshalAs(UnmanagedType.LPUTF8Str)] string cmd, [MarshalAs(UnmanagedType.LPUTF8Str)] string arg, byte* res, int res_len, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint avfilter_version_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVFormatContext* avformat_alloc_context_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_alloc_output_context2_delegate(AVFormatContext** ctx, AVOutputFormat* oformat, [MarshalAs(UnmanagedType.LPUTF8Str)] string format_name, [MarshalAs(UnmanagedType.LPUTF8Str)] string filename);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avformat_close_input_delegate(AVFormatContext** s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avformat_configuration_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_find_stream_info_delegate(AVFormatContext* ic, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_flush_delegate(AVFormatContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avformat_free_context_delegate(AVFormatContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* avformat_get_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecTag* avformat_get_mov_audio_tags_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecTag* avformat_get_mov_video_tags_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecTag* avformat_get_riff_audio_tags_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVCodecTag* avformat_get_riff_video_tags_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_index_get_entries_count_delegate(AVStream* st);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVIndexEntry* avformat_index_get_entry_delegate(AVStream* st, int idx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVIndexEntry* avformat_index_get_entry_from_timestamp_delegate(AVStream* st, long wanted_timestamp, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_init_output_delegate(AVFormatContext* s, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avformat_license_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_match_stream_specifier_delegate(AVFormatContext* s, AVStream* st, [MarshalAs(UnmanagedType.LPUTF8Str)] string spec);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int avformat_network_deinit_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int avformat_network_init_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVStream* avformat_new_stream_delegate(AVFormatContext* s, AVCodec* c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_open_input_delegate(AVFormatContext** ps, [MarshalAs(UnmanagedType.LPUTF8Str)] string url, AVInputFormat* fmt, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_query_codec_delegate(AVOutputFormat* ofmt, AVCodecID codec_id, int std_compliance);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_queue_attached_pictures_delegate(AVFormatContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_seek_file_delegate(AVFormatContext* s, int stream_index, long min_ts, long ts, long max_ts, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_stream_group_add_stream_delegate(AVStreamGroup* stg, AVStream* st);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVStreamGroup* avformat_stream_group_create_delegate(AVFormatContext* s, AVStreamGroupParamsType type, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avformat_stream_group_name_delegate(AVStreamGroupParamsType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_transfer_internal_stream_timing_info_delegate(AVOutputFormat* ofmt, AVStream* ost, AVStream* ist, AVTimebaseSource copy_tb);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint avformat_version_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avformat_write_header_delegate(AVFormatContext* s, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_accept_delegate(AVIOContext* s, AVIOContext** c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVIOContext* avio_alloc_context_delegate(byte* buffer, int buffer_size, int write_flag, void* opaque, avio_alloc_context_read_packet_func read_packet, avio_alloc_context_write_packet_func write_packet, avio_alloc_context_seek_func seek);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int avio_check_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string url, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_close_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_close_dir_delegate(AVIODirContext** s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_close_dyn_buf_delegate(AVIOContext* s, byte** pbuffer);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_closep_delegate(AVIOContext** s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_context_free_delegate(AVIOContext** s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public unsafe delegate string avio_enum_protocols_delegate(void** opaque, int output);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_feof_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avio_find_protocol_name_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string url);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_flush_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_free_directory_entry_delegate(AVIODirEntry** entry);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_get_dyn_buf_delegate(AVIOContext* s, byte** pbuffer);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_get_str_delegate(AVIOContext* pb, int maxlen, byte* buf, int buflen);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_get_str16be_delegate(AVIOContext* pb, int maxlen, byte* buf, int buflen);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_get_str16le_delegate(AVIOContext* pb, int maxlen, byte* buf, int buflen);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_handshake_delegate(AVIOContext* c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_open_delegate(AVIOContext** s, [MarshalAs(UnmanagedType.LPUTF8Str)] string url, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_open_dir_delegate(AVIODirContext** s, [MarshalAs(UnmanagedType.LPUTF8Str)] string url, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_open_dyn_buf_delegate(AVIOContext** s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_open2_delegate(AVIOContext** s, [MarshalAs(UnmanagedType.LPUTF8Str)] string url, int flags, AVIOInterruptCB* int_cb, AVDictionary** options);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_pause_delegate(AVIOContext* h, int pause);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_print_string_array_delegate(AVIOContext* s, byte*[] strings);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_printf_delegate(AVIOContext* s, [MarshalAs(UnmanagedType.LPUTF8Str)] string fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* avio_protocol_get_class_delegate([MarshalAs(UnmanagedType.LPUTF8Str)] string name);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_put_str_delegate(AVIOContext* s, [MarshalAs(UnmanagedType.LPUTF8Str)] string str);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_put_str16be_delegate(AVIOContext* s, [MarshalAs(UnmanagedType.LPUTF8Str)] string str);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_put_str16le_delegate(AVIOContext* s, [MarshalAs(UnmanagedType.LPUTF8Str)] string str);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_r8_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint avio_rb16_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint avio_rb24_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint avio_rb32_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate ulong avio_rb64_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_read_delegate(AVIOContext* s, byte* buf, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_read_dir_delegate(AVIODirContext* s, AVIODirEntry** next);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_read_partial_delegate(AVIOContext* s, byte* buf, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_read_to_bprint_delegate(AVIOContext* h, AVBPrint* pb, ulong max_size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint avio_rl16_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint avio_rl24_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint avio_rl32_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate ulong avio_rl64_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate long avio_seek_delegate(AVIOContext* s, long offset, int whence);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate long avio_seek_time_delegate(AVIOContext* h, int stream_index, long timestamp, int flags);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate long avio_size_delegate(AVIOContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate long avio_skip_delegate(AVIOContext* s, long offset);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int avio_vprintf_delegate(AVIOContext* s, [MarshalAs(UnmanagedType.LPUTF8Str)] string fmt, byte* ap);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_w8_delegate(AVIOContext* s, int b);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_wb16_delegate(AVIOContext* s, uint val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_wb24_delegate(AVIOContext* s, uint val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_wb32_delegate(AVIOContext* s, uint val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_wb64_delegate(AVIOContext* s, ulong val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_wl16_delegate(AVIOContext* s, uint val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_wl24_delegate(AVIOContext* s, uint val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_wl32_delegate(AVIOContext* s, uint val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_wl64_delegate(AVIOContext* s, ulong val);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_write_delegate(AVIOContext* s, byte* buf, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avio_write_marker_delegate(AVIOContext* s, long time, AVIODataMarkerType type);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void avsubtitle_free_delegate(AVSubtitle* sub);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avutil_configuration_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string avutil_license_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint avutil_version_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate SwrContext* swr_alloc_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_alloc_set_opts2_delegate(SwrContext** ps, AVChannelLayout* out_ch_layout, AVSampleFormat out_sample_fmt, int out_sample_rate, AVChannelLayout* in_ch_layout, AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void* log_ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_build_matrix2_delegate(AVChannelLayout* in_layout, AVChannelLayout* out_layout, double center_mix_level, double surround_mix_level, double lfe_mix_level, double maxval, double rematrix_volume, double* matrix, long stride, AVMatrixEncoding matrix_encoding, void* log_context);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void swr_close_delegate(SwrContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_config_frame_delegate(SwrContext* swr, AVFrame* @out, AVFrame* @in);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_convert_delegate(SwrContext* s, byte** @out, int out_count, byte** @in, int in_count);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_convert_frame_delegate(SwrContext* swr, AVFrame* output, AVFrame* input);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_drop_output_delegate(SwrContext* s, int count);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void swr_free_delegate(SwrContext** s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* swr_get_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate long swr_get_delay_delegate(SwrContext* s, long @base);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_get_out_samples_delegate(SwrContext* s, int in_samples);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_init_delegate(SwrContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_inject_silence_delegate(SwrContext* s, int count);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_is_initialized_delegate(SwrContext* s);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate long swr_next_pts_delegate(SwrContext* s, long pts);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_set_channel_mapping_delegate(SwrContext* s, int* channel_map);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_set_compensation_delegate(SwrContext* s, int sample_delta, int compensation_distance);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int swr_set_matrix_delegate(SwrContext* s, double* matrix, int stride);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string swresample_configuration_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string swresample_license_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint swresample_version_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate SwsContext* sws_alloc_context_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate SwsVector* sws_allocVec_delegate(int length);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_convertPalette8ToPacked24_delegate(byte* src, byte* dst, int num_pixels, byte* palette);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_convertPalette8ToPacked32_delegate(byte* src, byte* dst, int num_pixels, byte* palette);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_frame_end_delegate(SwsContext* c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_frame_setup_delegate(SwsContext* ctx, AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_frame_start_delegate(SwsContext* c, AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_free_context_delegate(SwsContext** ctx);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_freeContext_delegate(SwsContext* swsContext);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_freeFilter_delegate(SwsFilter* filter);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_freeVec_delegate(SwsVector* a);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate AVClass* sws_get_class_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate SwsContext* sws_getCachedContext_delegate(SwsContext* context, int srcW, int srcH, AVPixelFormat srcFormat, int dstW, int dstH, AVPixelFormat dstFormat, int flags, SwsFilter* srcFilter, SwsFilter* dstFilter, double* param);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int* sws_getCoefficients_delegate(int colorspace);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_getColorspaceDetails_delegate(SwsContext* c, int** inv_table, int* srcRange, int** table, int* dstRange, int* brightness, int* contrast, int* saturation);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate SwsContext* sws_getContext_delegate(int srcW, int srcH, AVPixelFormat srcFormat, int dstW, int dstH, AVPixelFormat dstFormat, int flags, SwsFilter* srcFilter, SwsFilter* dstFilter, double* param);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate SwsFilter* sws_getDefaultFilter_delegate(float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate SwsVector* sws_getGaussianVec_delegate(double variance, double quality);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_init_context_delegate(SwsContext* sws_context, SwsFilter* srcFilter, SwsFilter* dstFilter);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_is_noop_delegate(AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int sws_isSupportedEndiannessConversion_delegate(AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int sws_isSupportedInput_delegate(AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int sws_isSupportedOutput_delegate(AVPixelFormat pix_fmt);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_normalizeVec_delegate(SwsVector* a, double height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_receive_slice_delegate(SwsContext* c, uint slice_start, uint slice_height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate uint sws_receive_slice_alignment_delegate(SwsContext* c);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_scale_delegate(SwsContext* c, byte*[] srcSlice, int[] srcStride, int srcSliceY, int srcSliceH, byte*[] dst, int[] dstStride);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_scale_frame_delegate(SwsContext* c, AVFrame* dst, AVFrame* src);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate void sws_scaleVec_delegate(SwsVector* a, double scalar);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_send_slice_delegate(SwsContext* c, uint slice_start, uint slice_height);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_setColorspaceDetails_delegate(SwsContext* c, in int_array4 inv_table, int srcRange, in int_array4 table, int dstRange, int brightness, int contrast, int saturation);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int sws_test_colorspace_delegate(AVColorSpace colorspace, int output);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int sws_test_format_delegate(AVPixelFormat format, int output);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public unsafe delegate int sws_test_frame_delegate(AVFrame* frame, int output);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int sws_test_primaries_delegate(AVColorPrimaries primaries, int output);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int sws_test_transfer_delegate(AVColorTransferCharacteristic trc, int output);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string swscale_configuration_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "FFmpeg.AutoGen.ConstCharPtrMarshaler")]
		public delegate string swscale_license_delegate();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate uint swscale_version_delegate();

		public static av_add_index_entry_delegate av_add_index_entry;

		public static av_add_q_delegate av_add_q;

		public static av_add_stable_delegate av_add_stable;

		public static av_append_packet_delegate av_append_packet;

		public static av_audio_fifo_alloc_delegate av_audio_fifo_alloc;

		public static av_audio_fifo_drain_delegate av_audio_fifo_drain;

		public static av_audio_fifo_free_delegate av_audio_fifo_free;

		public static av_audio_fifo_peek_delegate av_audio_fifo_peek;

		public static av_audio_fifo_peek_at_delegate av_audio_fifo_peek_at;

		public static av_audio_fifo_read_delegate av_audio_fifo_read;

		public static av_audio_fifo_realloc_delegate av_audio_fifo_realloc;

		public static av_audio_fifo_reset_delegate av_audio_fifo_reset;

		public static av_audio_fifo_size_delegate av_audio_fifo_size;

		public static av_audio_fifo_space_delegate av_audio_fifo_space;

		public static av_audio_fifo_write_delegate av_audio_fifo_write;

		public static av_bessel_i0_delegate av_bessel_i0;

		public static av_bsf_alloc_delegate av_bsf_alloc;

		public static av_bsf_flush_delegate av_bsf_flush;

		public static av_bsf_free_delegate av_bsf_free;

		public static av_bsf_get_by_name_delegate av_bsf_get_by_name;

		public static av_bsf_get_class_delegate av_bsf_get_class;

		public static av_bsf_get_null_filter_delegate av_bsf_get_null_filter;

		public static av_bsf_init_delegate av_bsf_init;

		public static av_bsf_iterate_delegate av_bsf_iterate;

		public static av_bsf_list_alloc_delegate av_bsf_list_alloc;

		public static av_bsf_list_append_delegate av_bsf_list_append;

		public static av_bsf_list_append2_delegate av_bsf_list_append2;

		public static av_bsf_list_finalize_delegate av_bsf_list_finalize;

		public static av_bsf_list_free_delegate av_bsf_list_free;

		public static av_bsf_list_parse_str_delegate av_bsf_list_parse_str;

		public static av_bsf_receive_packet_delegate av_bsf_receive_packet;

		public static av_bsf_send_packet_delegate av_bsf_send_packet;

		public static av_buffer_alloc_delegate av_buffer_alloc;

		public static av_buffer_allocz_delegate av_buffer_allocz;

		public static av_buffer_create_delegate av_buffer_create;

		public static av_buffer_default_free_delegate av_buffer_default_free;

		public static av_buffer_get_opaque_delegate av_buffer_get_opaque;

		public static av_buffer_get_ref_count_delegate av_buffer_get_ref_count;

		public static av_buffer_is_writable_delegate av_buffer_is_writable;

		public static av_buffer_make_writable_delegate av_buffer_make_writable;

		public static av_buffer_pool_buffer_get_opaque_delegate av_buffer_pool_buffer_get_opaque;

		public static av_buffer_pool_get_delegate av_buffer_pool_get;

		public static av_buffer_pool_init_delegate av_buffer_pool_init;

		public static av_buffer_pool_init2_delegate av_buffer_pool_init2;

		public static av_buffer_pool_uninit_delegate av_buffer_pool_uninit;

		public static av_buffer_realloc_delegate av_buffer_realloc;

		public static av_buffer_ref_delegate av_buffer_ref;

		public static av_buffer_replace_delegate av_buffer_replace;

		public static av_buffer_unref_delegate av_buffer_unref;

		public static av_buffersink_get_ch_layout_delegate av_buffersink_get_ch_layout;

		public static av_buffersink_get_channels_delegate av_buffersink_get_channels;

		public static av_buffersink_get_color_range_delegate av_buffersink_get_color_range;

		public static av_buffersink_get_colorspace_delegate av_buffersink_get_colorspace;

		public static av_buffersink_get_format_delegate av_buffersink_get_format;

		public static av_buffersink_get_frame_delegate av_buffersink_get_frame;

		public static av_buffersink_get_frame_flags_delegate av_buffersink_get_frame_flags;

		public static av_buffersink_get_frame_rate_delegate av_buffersink_get_frame_rate;

		public static av_buffersink_get_h_delegate av_buffersink_get_h;

		public static av_buffersink_get_hw_frames_ctx_delegate av_buffersink_get_hw_frames_ctx;

		public static av_buffersink_get_sample_aspect_ratio_delegate av_buffersink_get_sample_aspect_ratio;

		public static av_buffersink_get_sample_rate_delegate av_buffersink_get_sample_rate;

		public static av_buffersink_get_samples_delegate av_buffersink_get_samples;

		public static av_buffersink_get_side_data_delegate av_buffersink_get_side_data;

		public static av_buffersink_get_time_base_delegate av_buffersink_get_time_base;

		public static av_buffersink_get_type_delegate av_buffersink_get_type;

		public static av_buffersink_get_w_delegate av_buffersink_get_w;

		public static av_buffersink_set_frame_size_delegate av_buffersink_set_frame_size;

		public static av_buffersrc_add_frame_delegate av_buffersrc_add_frame;

		public static av_buffersrc_add_frame_flags_delegate av_buffersrc_add_frame_flags;

		public static av_buffersrc_close_delegate av_buffersrc_close;

		public static av_buffersrc_get_nb_failed_requests_delegate av_buffersrc_get_nb_failed_requests;

		public static av_buffersrc_parameters_alloc_delegate av_buffersrc_parameters_alloc;

		public static av_buffersrc_parameters_set_delegate av_buffersrc_parameters_set;

		public static av_buffersrc_write_frame_delegate av_buffersrc_write_frame;

		public static av_calloc_delegate av_calloc;

		public static av_channel_description_delegate av_channel_description;

		public static av_channel_description_bprint_delegate av_channel_description_bprint;

		public static av_channel_from_string_delegate av_channel_from_string;

		public static av_channel_layout_ambisonic_order_delegate av_channel_layout_ambisonic_order;

		public static av_channel_layout_channel_from_index_delegate av_channel_layout_channel_from_index;

		public static av_channel_layout_channel_from_string_delegate av_channel_layout_channel_from_string;

		public static av_channel_layout_check_delegate av_channel_layout_check;

		public static av_channel_layout_compare_delegate av_channel_layout_compare;

		public static av_channel_layout_copy_delegate av_channel_layout_copy;

		public static av_channel_layout_custom_init_delegate av_channel_layout_custom_init;

		public static av_channel_layout_default_delegate av_channel_layout_default;

		public static av_channel_layout_describe_delegate av_channel_layout_describe;

		public static av_channel_layout_describe_bprint_delegate av_channel_layout_describe_bprint;

		public static av_channel_layout_from_mask_delegate av_channel_layout_from_mask;

		public static av_channel_layout_from_string_delegate av_channel_layout_from_string;

		public static av_channel_layout_index_from_channel_delegate av_channel_layout_index_from_channel;

		public static av_channel_layout_index_from_string_delegate av_channel_layout_index_from_string;

		public static av_channel_layout_retype_delegate av_channel_layout_retype;

		public static av_channel_layout_standard_delegate av_channel_layout_standard;

		public static av_channel_layout_subset_delegate av_channel_layout_subset;

		public static av_channel_layout_uninit_delegate av_channel_layout_uninit;

		public static av_channel_name_delegate av_channel_name;

		public static av_channel_name_bprint_delegate av_channel_name_bprint;

		public static av_chroma_location_enum_to_pos_delegate av_chroma_location_enum_to_pos;

		public static av_chroma_location_from_name_delegate av_chroma_location_from_name;

		public static av_chroma_location_name_delegate av_chroma_location_name;

		public static av_chroma_location_pos_to_enum_delegate av_chroma_location_pos_to_enum;

		public static av_codec_get_id_delegate av_codec_get_id;

		public static av_codec_get_tag_delegate av_codec_get_tag;

		public static av_codec_get_tag2_delegate av_codec_get_tag2;

		public static av_codec_is_decoder_delegate av_codec_is_decoder;

		public static av_codec_is_encoder_delegate av_codec_is_encoder;

		public static av_codec_iterate_delegate av_codec_iterate;

		public static av_color_primaries_from_name_delegate av_color_primaries_from_name;

		public static av_color_primaries_name_delegate av_color_primaries_name;

		public static av_color_range_from_name_delegate av_color_range_from_name;

		public static av_color_range_name_delegate av_color_range_name;

		public static av_color_space_from_name_delegate av_color_space_from_name;

		public static av_color_space_name_delegate av_color_space_name;

		public static av_color_transfer_from_name_delegate av_color_transfer_from_name;

		public static av_color_transfer_name_delegate av_color_transfer_name;

		public static av_compare_mod_delegate av_compare_mod;

		public static av_compare_ts_delegate av_compare_ts;

		public static av_container_fifo_alloc_avpacket_delegate av_container_fifo_alloc_avpacket;

		public static av_content_light_metadata_alloc_delegate av_content_light_metadata_alloc;

		public static av_content_light_metadata_create_side_data_delegate av_content_light_metadata_create_side_data;

		public static av_cpb_properties_alloc_delegate av_cpb_properties_alloc;

		public static av_cpu_count_delegate av_cpu_count;

		public static av_cpu_force_count_delegate av_cpu_force_count;

		public static av_cpu_max_align_delegate av_cpu_max_align;

		public static av_d2q_delegate av_d2q;

		public static av_d3d11va_alloc_context_delegate av_d3d11va_alloc_context;

		public static av_default_get_category_delegate av_default_get_category;

		public static av_default_item_name_delegate av_default_item_name;

		public static av_demuxer_iterate_delegate av_demuxer_iterate;

		public static av_dict_copy_delegate av_dict_copy;

		public static av_dict_count_delegate av_dict_count;

		public static av_dict_free_delegate av_dict_free;

		public static av_dict_get_delegate av_dict_get;

		public static av_dict_get_string_delegate av_dict_get_string;

		public static av_dict_iterate_delegate av_dict_iterate;

		public static av_dict_parse_string_delegate av_dict_parse_string;

		public static av_dict_set_delegate av_dict_set;

		public static av_dict_set_int_delegate av_dict_set_int;

		public static av_display_matrix_flip_delegate av_display_matrix_flip;

		public static av_display_rotation_get_delegate av_display_rotation_get;

		public static av_display_rotation_set_delegate av_display_rotation_set;

		public static av_disposition_from_string_delegate av_disposition_from_string;

		public static av_disposition_to_string_delegate av_disposition_to_string;

		public static av_div_q_delegate av_div_q;

		public static av_dump_format_delegate av_dump_format;

		public static av_dynamic_hdr_plus_alloc_delegate av_dynamic_hdr_plus_alloc;

		public static av_dynamic_hdr_plus_create_side_data_delegate av_dynamic_hdr_plus_create_side_data;

		public static av_dynamic_hdr_plus_from_t35_delegate av_dynamic_hdr_plus_from_t35;

		public static av_dynamic_hdr_plus_to_t35_delegate av_dynamic_hdr_plus_to_t35;

		public static av_dynarray_add_delegate av_dynarray_add;

		public static av_dynarray_add_nofree_delegate av_dynarray_add_nofree;

		public static av_dynarray2_add_delegate av_dynarray2_add;

		public static av_fast_malloc_delegate av_fast_malloc;

		public static av_fast_mallocz_delegate av_fast_mallocz;

		public static av_fast_padded_malloc_delegate av_fast_padded_malloc;

		public static av_fast_padded_mallocz_delegate av_fast_padded_mallocz;

		public static av_fast_realloc_delegate av_fast_realloc;

		public static av_file_map_delegate av_file_map;

		public static av_file_unmap_delegate av_file_unmap;

		public static av_filename_number_test_delegate av_filename_number_test;

		public static av_filter_iterate_delegate av_filter_iterate;

		public static av_find_best_pix_fmt_of_2_delegate av_find_best_pix_fmt_of_2;

		public static av_find_best_stream_delegate av_find_best_stream;

		public static av_find_default_stream_index_delegate av_find_default_stream_index;

		public static av_find_input_format_delegate av_find_input_format;

		public static av_find_nearest_q_idx_delegate av_find_nearest_q_idx;

		public static av_find_program_from_stream_delegate av_find_program_from_stream;

		public static av_force_cpu_flags_delegate av_force_cpu_flags;

		public static av_fourcc_make_string_delegate av_fourcc_make_string;

		public static av_frame_alloc_delegate av_frame_alloc;

		public static av_frame_apply_cropping_delegate av_frame_apply_cropping;

		public static av_frame_clone_delegate av_frame_clone;

		public static av_frame_copy_delegate av_frame_copy;

		public static av_frame_copy_props_delegate av_frame_copy_props;

		public static av_frame_free_delegate av_frame_free;

		public static av_frame_get_buffer_delegate av_frame_get_buffer;

		public static av_frame_get_plane_buffer_delegate av_frame_get_plane_buffer;

		public static av_frame_get_side_data_delegate av_frame_get_side_data;

		public static av_frame_is_writable_delegate av_frame_is_writable;

		public static av_frame_make_writable_delegate av_frame_make_writable;

		public static av_frame_move_ref_delegate av_frame_move_ref;

		public static av_frame_new_side_data_delegate av_frame_new_side_data;

		public static av_frame_new_side_data_from_buf_delegate av_frame_new_side_data_from_buf;

		public static av_frame_ref_delegate av_frame_ref;

		public static av_frame_remove_side_data_delegate av_frame_remove_side_data;

		public static av_frame_replace_delegate av_frame_replace;

		public static av_frame_side_data_add_delegate av_frame_side_data_add;

		public static av_frame_side_data_clone_delegate av_frame_side_data_clone;

		public static av_frame_side_data_desc_delegate av_frame_side_data_desc;

		public static av_frame_side_data_free_delegate av_frame_side_data_free;

		public static av_frame_side_data_get_c_delegate av_frame_side_data_get_c;

		public static av_frame_side_data_name_delegate av_frame_side_data_name;

		public static av_frame_side_data_new_delegate av_frame_side_data_new;

		public static av_frame_side_data_remove_delegate av_frame_side_data_remove;

		public static av_frame_side_data_remove_by_props_delegate av_frame_side_data_remove_by_props;

		public static av_frame_unref_delegate av_frame_unref;

		public static av_free_delegate av_free;

		public static av_freep_delegate av_freep;

		public static av_gcd_delegate av_gcd;

		public static av_gcd_q_delegate av_gcd_q;

		public static av_get_alt_sample_fmt_delegate av_get_alt_sample_fmt;

		public static av_get_audio_frame_duration_delegate av_get_audio_frame_duration;

		public static av_get_audio_frame_duration2_delegate av_get_audio_frame_duration2;

		public static av_get_bits_per_pixel_delegate av_get_bits_per_pixel;

		public static av_get_bits_per_sample_delegate av_get_bits_per_sample;

		public static av_get_bytes_per_sample_delegate av_get_bytes_per_sample;

		public static av_get_cpu_flags_delegate av_get_cpu_flags;

		public static av_get_exact_bits_per_sample_delegate av_get_exact_bits_per_sample;

		public static av_get_frame_filename_delegate av_get_frame_filename;

		public static av_get_frame_filename2_delegate av_get_frame_filename2;

		public static av_get_media_type_string_delegate av_get_media_type_string;

		public static av_get_output_timestamp_delegate av_get_output_timestamp;

		public static av_get_packed_sample_fmt_delegate av_get_packed_sample_fmt;

		public static av_get_packet_delegate av_get_packet;

		public static av_get_padded_bits_per_pixel_delegate av_get_padded_bits_per_pixel;

		public static av_get_pcm_codec_delegate av_get_pcm_codec;

		public static av_get_picture_type_char_delegate av_get_picture_type_char;

		public static av_get_pix_fmt_delegate av_get_pix_fmt;

		public static av_get_pix_fmt_loss_delegate av_get_pix_fmt_loss;

		public static av_get_pix_fmt_name_delegate av_get_pix_fmt_name;

		public static av_get_pix_fmt_string_delegate av_get_pix_fmt_string;

		public static av_get_planar_sample_fmt_delegate av_get_planar_sample_fmt;

		public static av_get_profile_name_delegate av_get_profile_name;

		public static av_get_sample_fmt_delegate av_get_sample_fmt;

		public static av_get_sample_fmt_name_delegate av_get_sample_fmt_name;

		public static av_get_sample_fmt_string_delegate av_get_sample_fmt_string;

		public static av_get_time_base_q_delegate av_get_time_base_q;

		public static av_gettime_delegate av_gettime;

		public static av_gettime_relative_delegate av_gettime_relative;

		public static av_gettime_relative_is_monotonic_delegate av_gettime_relative_is_monotonic;

		public static av_grow_packet_delegate av_grow_packet;

		public static av_guess_codec_delegate av_guess_codec;

		public static av_guess_format_delegate av_guess_format;

		public static av_guess_frame_rate_delegate av_guess_frame_rate;

		public static av_guess_sample_aspect_ratio_delegate av_guess_sample_aspect_ratio;

		public static av_hex_dump_delegate av_hex_dump;

		public static av_hex_dump_log_delegate av_hex_dump_log;

		public static av_hwdevice_ctx_alloc_delegate av_hwdevice_ctx_alloc;

		public static av_hwdevice_ctx_create_delegate av_hwdevice_ctx_create;

		public static av_hwdevice_ctx_create_derived_delegate av_hwdevice_ctx_create_derived;

		public static av_hwdevice_ctx_create_derived_opts_delegate av_hwdevice_ctx_create_derived_opts;

		public static av_hwdevice_ctx_init_delegate av_hwdevice_ctx_init;

		public static av_hwdevice_find_type_by_name_delegate av_hwdevice_find_type_by_name;

		public static av_hwdevice_get_hwframe_constraints_delegate av_hwdevice_get_hwframe_constraints;

		public static av_hwdevice_get_type_name_delegate av_hwdevice_get_type_name;

		public static av_hwdevice_hwconfig_alloc_delegate av_hwdevice_hwconfig_alloc;

		public static av_hwdevice_iterate_types_delegate av_hwdevice_iterate_types;

		public static av_hwframe_constraints_free_delegate av_hwframe_constraints_free;

		public static av_hwframe_ctx_alloc_delegate av_hwframe_ctx_alloc;

		public static av_hwframe_ctx_create_derived_delegate av_hwframe_ctx_create_derived;

		public static av_hwframe_ctx_init_delegate av_hwframe_ctx_init;

		public static av_hwframe_get_buffer_delegate av_hwframe_get_buffer;

		public static av_hwframe_map_delegate av_hwframe_map;

		public static av_hwframe_transfer_data_delegate av_hwframe_transfer_data;

		public static av_hwframe_transfer_get_formats_delegate av_hwframe_transfer_get_formats;

		public static av_image_alloc_delegate av_image_alloc;

		public static av_image_check_sar_delegate av_image_check_sar;

		public static av_image_check_size_delegate av_image_check_size;

		public static av_image_check_size2_delegate av_image_check_size2;

		public static av_image_copy_delegate av_image_copy;

		public static av_image_copy_plane_delegate av_image_copy_plane;

		public static av_image_copy_plane_uc_from_delegate av_image_copy_plane_uc_from;

		public static av_image_copy_to_buffer_delegate av_image_copy_to_buffer;

		public static av_image_copy_uc_from_delegate av_image_copy_uc_from;

		public static av_image_fill_arrays_delegate av_image_fill_arrays;

		public static av_image_fill_black_delegate av_image_fill_black;

		public static av_image_fill_color_delegate av_image_fill_color;

		public static av_image_fill_linesizes_delegate av_image_fill_linesizes;

		public static av_image_fill_max_pixsteps_delegate av_image_fill_max_pixsteps;

		public static av_image_fill_plane_sizes_delegate av_image_fill_plane_sizes;

		public static av_image_fill_pointers_delegate av_image_fill_pointers;

		public static av_image_get_buffer_size_delegate av_image_get_buffer_size;

		public static av_image_get_linesize_delegate av_image_get_linesize;

		public static av_index_search_timestamp_delegate av_index_search_timestamp;

		public static av_init_packet_delegate av_init_packet;

		public static av_input_audio_device_next_delegate av_input_audio_device_next;

		public static av_input_video_device_next_delegate av_input_video_device_next;

		public static av_int_list_length_for_size_delegate av_int_list_length_for_size;

		public static av_interleaved_write_frame_delegate av_interleaved_write_frame;

		public static av_interleaved_write_uncoded_frame_delegate av_interleaved_write_uncoded_frame;

		public static av_log_delegate av_log;

		public static av_log_default_callback_delegate av_log_default_callback;

		public static av_log_format_line_delegate av_log_format_line;

		public static av_log_format_line2_delegate av_log_format_line2;

		public static av_log_get_flags_delegate av_log_get_flags;

		public static av_log_get_level_delegate av_log_get_level;

		public static av_log_once_delegate av_log_once;

		public static av_log_set_callback_delegate av_log_set_callback;

		public static av_log_set_flags_delegate av_log_set_flags;

		public static av_log_set_level_delegate av_log_set_level;

		public static av_log2_delegate av_log2;

		public static av_log2_16bit_delegate av_log2_16bit;

		public static av_malloc_delegate av_malloc;

		public static av_malloc_array_delegate av_malloc_array;

		public static av_mallocz_delegate av_mallocz;

		public static av_mastering_display_metadata_alloc_delegate av_mastering_display_metadata_alloc;

		public static av_mastering_display_metadata_alloc_size_delegate av_mastering_display_metadata_alloc_size;

		public static av_mastering_display_metadata_create_side_data_delegate av_mastering_display_metadata_create_side_data;

		public static av_match_ext_delegate av_match_ext;

		public static av_max_alloc_delegate av_max_alloc;

		public static av_memcpy_backptr_delegate av_memcpy_backptr;

		public static av_memdup_delegate av_memdup;

		public static av_mul_q_delegate av_mul_q;

		public static av_muxer_iterate_delegate av_muxer_iterate;

		public static av_nearer_q_delegate av_nearer_q;

		public static av_new_packet_delegate av_new_packet;

		public static av_new_program_delegate av_new_program;

		public static av_opt_child_class_iterate_delegate av_opt_child_class_iterate;

		public static av_opt_child_next_delegate av_opt_child_next;

		public static av_opt_copy_delegate av_opt_copy;

		public static av_opt_eval_double_delegate av_opt_eval_double;

		public static av_opt_eval_flags_delegate av_opt_eval_flags;

		public static av_opt_eval_float_delegate av_opt_eval_float;

		public static av_opt_eval_int_delegate av_opt_eval_int;

		public static av_opt_eval_int64_delegate av_opt_eval_int64;

		public static av_opt_eval_q_delegate av_opt_eval_q;

		public static av_opt_eval_uint_delegate av_opt_eval_uint;

		public static av_opt_find_delegate av_opt_find;

		public static av_opt_find2_delegate av_opt_find2;

		public static av_opt_flag_is_set_delegate av_opt_flag_is_set;

		public static av_opt_free_delegate av_opt_free;

		public static av_opt_freep_ranges_delegate av_opt_freep_ranges;

		public static av_opt_get_delegate av_opt_get;

		public static av_opt_get_array_delegate av_opt_get_array;

		public static av_opt_get_array_size_delegate av_opt_get_array_size;

		public static av_opt_get_chlayout_delegate av_opt_get_chlayout;

		public static av_opt_get_dict_val_delegate av_opt_get_dict_val;

		public static av_opt_get_double_delegate av_opt_get_double;

		public static av_opt_get_image_size_delegate av_opt_get_image_size;

		public static av_opt_get_int_delegate av_opt_get_int;

		public static av_opt_get_key_value_delegate av_opt_get_key_value;

		public static av_opt_get_pixel_fmt_delegate av_opt_get_pixel_fmt;

		public static av_opt_get_q_delegate av_opt_get_q;

		public static av_opt_get_sample_fmt_delegate av_opt_get_sample_fmt;

		public static av_opt_get_video_rate_delegate av_opt_get_video_rate;

		public static av_opt_is_set_to_default_delegate av_opt_is_set_to_default;

		public static av_opt_is_set_to_default_by_name_delegate av_opt_is_set_to_default_by_name;

		public static av_opt_next_delegate av_opt_next;

		public static av_opt_ptr_delegate av_opt_ptr;

		public static av_opt_query_ranges_delegate av_opt_query_ranges;

		public static av_opt_query_ranges_default_delegate av_opt_query_ranges_default;

		public static av_opt_serialize_delegate av_opt_serialize;

		public static av_opt_set_delegate av_opt_set;

		public static av_opt_set_array_delegate av_opt_set_array;

		public static av_opt_set_bin_delegate av_opt_set_bin;

		public static av_opt_set_chlayout_delegate av_opt_set_chlayout;

		public static av_opt_set_defaults_delegate av_opt_set_defaults;

		public static av_opt_set_defaults2_delegate av_opt_set_defaults2;

		public static av_opt_set_dict_delegate av_opt_set_dict;

		public static av_opt_set_dict_val_delegate av_opt_set_dict_val;

		public static av_opt_set_dict2_delegate av_opt_set_dict2;

		public static av_opt_set_double_delegate av_opt_set_double;

		public static av_opt_set_from_string_delegate av_opt_set_from_string;

		public static av_opt_set_image_size_delegate av_opt_set_image_size;

		public static av_opt_set_int_delegate av_opt_set_int;

		public static av_opt_set_pixel_fmt_delegate av_opt_set_pixel_fmt;

		public static av_opt_set_q_delegate av_opt_set_q;

		public static av_opt_set_sample_fmt_delegate av_opt_set_sample_fmt;

		public static av_opt_set_video_rate_delegate av_opt_set_video_rate;

		public static av_opt_show2_delegate av_opt_show2;

		public static av_output_audio_device_next_delegate av_output_audio_device_next;

		public static av_output_video_device_next_delegate av_output_video_device_next;

		public static av_packet_add_side_data_delegate av_packet_add_side_data;

		public static av_packet_alloc_delegate av_packet_alloc;

		public static av_packet_clone_delegate av_packet_clone;

		public static av_packet_copy_props_delegate av_packet_copy_props;

		public static av_packet_free_delegate av_packet_free;

		public static av_packet_free_side_data_delegate av_packet_free_side_data;

		public static av_packet_from_data_delegate av_packet_from_data;

		public static av_packet_get_side_data_delegate av_packet_get_side_data;

		public static av_packet_make_refcounted_delegate av_packet_make_refcounted;

		public static av_packet_make_writable_delegate av_packet_make_writable;

		public static av_packet_move_ref_delegate av_packet_move_ref;

		public static av_packet_new_side_data_delegate av_packet_new_side_data;

		public static av_packet_pack_dictionary_delegate av_packet_pack_dictionary;

		public static av_packet_ref_delegate av_packet_ref;

		public static av_packet_rescale_ts_delegate av_packet_rescale_ts;

		public static av_packet_shrink_side_data_delegate av_packet_shrink_side_data;

		public static av_packet_side_data_add_delegate av_packet_side_data_add;

		public static av_packet_side_data_free_delegate av_packet_side_data_free;

		public static av_packet_side_data_get_delegate av_packet_side_data_get;

		public static av_packet_side_data_name_delegate av_packet_side_data_name;

		public static av_packet_side_data_new_delegate av_packet_side_data_new;

		public static av_packet_side_data_remove_delegate av_packet_side_data_remove;

		public static av_packet_unpack_dictionary_delegate av_packet_unpack_dictionary;

		public static av_packet_unref_delegate av_packet_unref;

		public static av_parse_cpu_caps_delegate av_parse_cpu_caps;

		public static av_parser_close_delegate av_parser_close;

		public static av_parser_init_delegate av_parser_init;

		public static av_parser_iterate_delegate av_parser_iterate;

		public static av_parser_parse2_delegate av_parser_parse2;

		public static av_pix_fmt_count_planes_delegate av_pix_fmt_count_planes;

		public static av_pix_fmt_desc_get_delegate av_pix_fmt_desc_get;

		public static av_pix_fmt_desc_get_id_delegate av_pix_fmt_desc_get_id;

		public static av_pix_fmt_desc_next_delegate av_pix_fmt_desc_next;

		public static av_pix_fmt_get_chroma_sub_sample_delegate av_pix_fmt_get_chroma_sub_sample;

		public static av_pix_fmt_swap_endianness_delegate av_pix_fmt_swap_endianness;

		public static av_pkt_dump_log2_delegate av_pkt_dump_log2;

		public static av_pkt_dump2_delegate av_pkt_dump2;

		public static av_probe_input_buffer_delegate av_probe_input_buffer;

		public static av_probe_input_buffer2_delegate av_probe_input_buffer2;

		public static av_probe_input_format_delegate av_probe_input_format;

		public static av_probe_input_format2_delegate av_probe_input_format2;

		public static av_probe_input_format3_delegate av_probe_input_format3;

		public static av_program_add_stream_index_delegate av_program_add_stream_index;

		public static av_q2intfloat_delegate av_q2intfloat;

		public static av_read_frame_delegate av_read_frame;

		public static av_read_image_line_delegate av_read_image_line;

		public static av_read_image_line2_delegate av_read_image_line2;

		public static av_read_pause_delegate av_read_pause;

		public static av_read_play_delegate av_read_play;

		public static av_realloc_delegate av_realloc;

		public static av_realloc_array_delegate av_realloc_array;

		public static av_realloc_f_delegate av_realloc_f;

		public static av_reallocp_delegate av_reallocp;

		public static av_reallocp_array_delegate av_reallocp_array;

		public static av_reduce_delegate av_reduce;

		public static av_rescale_delegate av_rescale;

		public static av_rescale_delta_delegate av_rescale_delta;

		public static av_rescale_q_delegate av_rescale_q;

		public static av_rescale_q_rnd_delegate av_rescale_q_rnd;

		public static av_rescale_rnd_delegate av_rescale_rnd;

		public static av_sample_fmt_is_planar_delegate av_sample_fmt_is_planar;

		public static av_samples_alloc_delegate av_samples_alloc;

		public static av_samples_alloc_array_and_samples_delegate av_samples_alloc_array_and_samples;

		public static av_samples_copy_delegate av_samples_copy;

		public static av_samples_fill_arrays_delegate av_samples_fill_arrays;

		public static av_samples_get_buffer_size_delegate av_samples_get_buffer_size;

		public static av_samples_set_silence_delegate av_samples_set_silence;

		public static av_sdp_create_delegate av_sdp_create;

		public static av_seek_frame_delegate av_seek_frame;

		public static av_set_options_string_delegate av_set_options_string;

		public static av_shrink_packet_delegate av_shrink_packet;

		public static av_size_mult_delegate av_size_mult;

		public static av_strdup_delegate av_strdup;

		public static av_stream_get_class_delegate av_stream_get_class;

		public static av_stream_get_codec_timebase_delegate av_stream_get_codec_timebase;

		public static av_stream_get_parser_delegate av_stream_get_parser;

		public static av_stream_group_get_class_delegate av_stream_group_get_class;

		public static av_strerror_delegate av_strerror;

		public static av_strndup_delegate av_strndup;

		public static av_sub_q_delegate av_sub_q;

		public static av_timecode_adjust_ntsc_framenum2_delegate av_timecode_adjust_ntsc_framenum2;

		public static av_timecode_check_frame_rate_delegate av_timecode_check_frame_rate;

		public static av_timecode_get_smpte_delegate av_timecode_get_smpte;

		public static av_timecode_get_smpte_from_framenum_delegate av_timecode_get_smpte_from_framenum;

		public static av_timecode_init_delegate av_timecode_init;

		public static av_timecode_init_from_components_delegate av_timecode_init_from_components;

		public static av_timecode_init_from_string_delegate av_timecode_init_from_string;

		public static av_timecode_make_mpeg_tc_string_delegate av_timecode_make_mpeg_tc_string;

		public static av_timecode_make_smpte_tc_string_delegate av_timecode_make_smpte_tc_string;

		public static av_timecode_make_smpte_tc_string2_delegate av_timecode_make_smpte_tc_string2;

		public static av_timecode_make_string_delegate av_timecode_make_string;

		public static av_tree_destroy_delegate av_tree_destroy;

		public static av_tree_enumerate_delegate av_tree_enumerate;

		public static av_tree_find_delegate av_tree_find;

		public static av_tree_insert_delegate av_tree_insert;

		public static av_tree_node_alloc_delegate av_tree_node_alloc;

		public static av_url_split_delegate av_url_split;

		public static av_usleep_delegate av_usleep;

		public static av_version_info_delegate av_version_info;

		public static av_vlog_delegate av_vlog;

		public static av_write_frame_delegate av_write_frame;

		public static av_write_image_line_delegate av_write_image_line;

		public static av_write_image_line2_delegate av_write_image_line2;

		public static av_write_trailer_delegate av_write_trailer;

		public static av_write_uncoded_frame_delegate av_write_uncoded_frame;

		public static av_write_uncoded_frame_query_delegate av_write_uncoded_frame_query;

		public static av_xiphlacing_delegate av_xiphlacing;

		public static avcodec_align_dimensions_delegate avcodec_align_dimensions;

		public static avcodec_align_dimensions2_delegate avcodec_align_dimensions2;

		public static avcodec_alloc_context3_delegate avcodec_alloc_context3;

		public static avcodec_configuration_delegate avcodec_configuration;

		public static avcodec_decode_subtitle2_delegate avcodec_decode_subtitle2;

		public static avcodec_default_execute_delegate avcodec_default_execute;

		public static avcodec_default_execute2_delegate avcodec_default_execute2;

		public static avcodec_default_get_buffer2_delegate avcodec_default_get_buffer2;

		public static avcodec_default_get_encode_buffer_delegate avcodec_default_get_encode_buffer;

		public static avcodec_default_get_format_delegate avcodec_default_get_format;

		public static avcodec_descriptor_get_delegate avcodec_descriptor_get;

		public static avcodec_descriptor_get_by_name_delegate avcodec_descriptor_get_by_name;

		public static avcodec_descriptor_next_delegate avcodec_descriptor_next;

		public static avcodec_encode_subtitle_delegate avcodec_encode_subtitle;

		public static avcodec_fill_audio_frame_delegate avcodec_fill_audio_frame;

		public static avcodec_find_best_pix_fmt_of_list_delegate avcodec_find_best_pix_fmt_of_list;

		public static avcodec_find_decoder_delegate avcodec_find_decoder;

		public static avcodec_find_decoder_by_name_delegate avcodec_find_decoder_by_name;

		public static avcodec_find_encoder_delegate avcodec_find_encoder;

		public static avcodec_find_encoder_by_name_delegate avcodec_find_encoder_by_name;

		public static avcodec_flush_buffers_delegate avcodec_flush_buffers;

		public static avcodec_free_context_delegate avcodec_free_context;

		public static avcodec_get_class_delegate avcodec_get_class;

		public static avcodec_get_hw_config_delegate avcodec_get_hw_config;

		public static avcodec_get_hw_frames_parameters_delegate avcodec_get_hw_frames_parameters;

		public static avcodec_get_name_delegate avcodec_get_name;

		public static avcodec_get_subtitle_rect_class_delegate avcodec_get_subtitle_rect_class;

		public static avcodec_get_supported_config_delegate avcodec_get_supported_config;

		public static avcodec_get_type_delegate avcodec_get_type;

		public static avcodec_is_open_delegate avcodec_is_open;

		public static avcodec_license_delegate avcodec_license;

		public static avcodec_open2_delegate avcodec_open2;

		public static avcodec_parameters_alloc_delegate avcodec_parameters_alloc;

		public static avcodec_parameters_copy_delegate avcodec_parameters_copy;

		public static avcodec_parameters_free_delegate avcodec_parameters_free;

		public static avcodec_parameters_from_context_delegate avcodec_parameters_from_context;

		public static avcodec_parameters_to_context_delegate avcodec_parameters_to_context;

		public static avcodec_pix_fmt_to_codec_tag_delegate avcodec_pix_fmt_to_codec_tag;

		public static avcodec_profile_name_delegate avcodec_profile_name;

		public static avcodec_receive_frame_delegate avcodec_receive_frame;

		public static avcodec_receive_packet_delegate avcodec_receive_packet;

		public static avcodec_send_frame_delegate avcodec_send_frame;

		public static avcodec_send_packet_delegate avcodec_send_packet;

		public static avcodec_string_delegate avcodec_string;

		public static avcodec_version_delegate avcodec_version;

		public static avdevice_app_to_dev_control_message_delegate avdevice_app_to_dev_control_message;

		public static avdevice_configuration_delegate avdevice_configuration;

		public static avdevice_dev_to_app_control_message_delegate avdevice_dev_to_app_control_message;

		public static avdevice_free_list_devices_delegate avdevice_free_list_devices;

		public static avdevice_license_delegate avdevice_license;

		public static avdevice_list_devices_delegate avdevice_list_devices;

		public static avdevice_list_input_sources_delegate avdevice_list_input_sources;

		public static avdevice_list_output_sinks_delegate avdevice_list_output_sinks;

		public static avdevice_register_all_delegate avdevice_register_all;

		public static avdevice_version_delegate avdevice_version;

		public static avfilter_configuration_delegate avfilter_configuration;

		public static avfilter_filter_pad_count_delegate avfilter_filter_pad_count;

		public static avfilter_free_delegate avfilter_free;

		public static avfilter_get_by_name_delegate avfilter_get_by_name;

		public static avfilter_get_class_delegate avfilter_get_class;

		public static avfilter_graph_alloc_delegate avfilter_graph_alloc;

		public static avfilter_graph_alloc_filter_delegate avfilter_graph_alloc_filter;

		public static avfilter_graph_config_delegate avfilter_graph_config;

		public static avfilter_graph_create_filter_delegate avfilter_graph_create_filter;

		public static avfilter_graph_dump_delegate avfilter_graph_dump;

		public static avfilter_graph_free_delegate avfilter_graph_free;

		public static avfilter_graph_get_filter_delegate avfilter_graph_get_filter;

		public static avfilter_graph_parse_delegate avfilter_graph_parse;

		public static avfilter_graph_parse_ptr_delegate avfilter_graph_parse_ptr;

		public static avfilter_graph_parse2_delegate avfilter_graph_parse2;

		public static avfilter_graph_queue_command_delegate avfilter_graph_queue_command;

		public static avfilter_graph_request_oldest_delegate avfilter_graph_request_oldest;

		public static avfilter_graph_segment_apply_delegate avfilter_graph_segment_apply;

		public static avfilter_graph_segment_apply_opts_delegate avfilter_graph_segment_apply_opts;

		public static avfilter_graph_segment_create_filters_delegate avfilter_graph_segment_create_filters;

		public static avfilter_graph_segment_free_delegate avfilter_graph_segment_free;

		public static avfilter_graph_segment_init_delegate avfilter_graph_segment_init;

		public static avfilter_graph_segment_link_delegate avfilter_graph_segment_link;

		public static avfilter_graph_segment_parse_delegate avfilter_graph_segment_parse;

		public static avfilter_graph_send_command_delegate avfilter_graph_send_command;

		public static avfilter_graph_set_auto_convert_delegate avfilter_graph_set_auto_convert;

		public static avfilter_init_dict_delegate avfilter_init_dict;

		public static avfilter_init_str_delegate avfilter_init_str;

		public static avfilter_inout_alloc_delegate avfilter_inout_alloc;

		public static avfilter_inout_free_delegate avfilter_inout_free;

		public static avfilter_insert_filter_delegate avfilter_insert_filter;

		public static avfilter_license_delegate avfilter_license;

		public static avfilter_link_delegate avfilter_link;

		public static avfilter_link_get_hw_frames_ctx_delegate avfilter_link_get_hw_frames_ctx;

		public static avfilter_pad_get_name_delegate avfilter_pad_get_name;

		public static avfilter_pad_get_type_delegate avfilter_pad_get_type;

		public static avfilter_process_command_delegate avfilter_process_command;

		public static avfilter_version_delegate avfilter_version;

		public static avformat_alloc_context_delegate avformat_alloc_context;

		public static avformat_alloc_output_context2_delegate avformat_alloc_output_context2;

		public static avformat_close_input_delegate avformat_close_input;

		public static avformat_configuration_delegate avformat_configuration;

		public static avformat_find_stream_info_delegate avformat_find_stream_info;

		public static avformat_flush_delegate avformat_flush;

		public static avformat_free_context_delegate avformat_free_context;

		public static avformat_get_class_delegate avformat_get_class;

		public static avformat_get_mov_audio_tags_delegate avformat_get_mov_audio_tags;

		public static avformat_get_mov_video_tags_delegate avformat_get_mov_video_tags;

		public static avformat_get_riff_audio_tags_delegate avformat_get_riff_audio_tags;

		public static avformat_get_riff_video_tags_delegate avformat_get_riff_video_tags;

		public static avformat_index_get_entries_count_delegate avformat_index_get_entries_count;

		public static avformat_index_get_entry_delegate avformat_index_get_entry;

		public static avformat_index_get_entry_from_timestamp_delegate avformat_index_get_entry_from_timestamp;

		public static avformat_init_output_delegate avformat_init_output;

		public static avformat_license_delegate avformat_license;

		public static avformat_match_stream_specifier_delegate avformat_match_stream_specifier;

		public static avformat_network_deinit_delegate avformat_network_deinit;

		public static avformat_network_init_delegate avformat_network_init;

		public static avformat_new_stream_delegate avformat_new_stream;

		public static avformat_open_input_delegate avformat_open_input;

		public static avformat_query_codec_delegate avformat_query_codec;

		public static avformat_queue_attached_pictures_delegate avformat_queue_attached_pictures;

		public static avformat_seek_file_delegate avformat_seek_file;

		public static avformat_stream_group_add_stream_delegate avformat_stream_group_add_stream;

		public static avformat_stream_group_create_delegate avformat_stream_group_create;

		public static avformat_stream_group_name_delegate avformat_stream_group_name;

		public static avformat_transfer_internal_stream_timing_info_delegate avformat_transfer_internal_stream_timing_info;

		public static avformat_version_delegate avformat_version;

		public static avformat_write_header_delegate avformat_write_header;

		public static avio_accept_delegate avio_accept;

		public static avio_alloc_context_delegate avio_alloc_context;

		public static avio_check_delegate avio_check;

		public static avio_close_delegate avio_close;

		public static avio_close_dir_delegate avio_close_dir;

		public static avio_close_dyn_buf_delegate avio_close_dyn_buf;

		public static avio_closep_delegate avio_closep;

		public static avio_context_free_delegate avio_context_free;

		public static avio_enum_protocols_delegate avio_enum_protocols;

		public static avio_feof_delegate avio_feof;

		public static avio_find_protocol_name_delegate avio_find_protocol_name;

		public static avio_flush_delegate avio_flush;

		public static avio_free_directory_entry_delegate avio_free_directory_entry;

		public static avio_get_dyn_buf_delegate avio_get_dyn_buf;

		public static avio_get_str_delegate avio_get_str;

		public static avio_get_str16be_delegate avio_get_str16be;

		public static avio_get_str16le_delegate avio_get_str16le;

		public static avio_handshake_delegate avio_handshake;

		public static avio_open_delegate avio_open;

		public static avio_open_dir_delegate avio_open_dir;

		public static avio_open_dyn_buf_delegate avio_open_dyn_buf;

		public static avio_open2_delegate avio_open2;

		public static avio_pause_delegate avio_pause;

		public static avio_print_string_array_delegate avio_print_string_array;

		public static avio_printf_delegate avio_printf;

		public static avio_protocol_get_class_delegate avio_protocol_get_class;

		public static avio_put_str_delegate avio_put_str;

		public static avio_put_str16be_delegate avio_put_str16be;

		public static avio_put_str16le_delegate avio_put_str16le;

		public static avio_r8_delegate avio_r8;

		public static avio_rb16_delegate avio_rb16;

		public static avio_rb24_delegate avio_rb24;

		public static avio_rb32_delegate avio_rb32;

		public static avio_rb64_delegate avio_rb64;

		public static avio_read_delegate avio_read;

		public static avio_read_dir_delegate avio_read_dir;

		public static avio_read_partial_delegate avio_read_partial;

		public static avio_read_to_bprint_delegate avio_read_to_bprint;

		public static avio_rl16_delegate avio_rl16;

		public static avio_rl24_delegate avio_rl24;

		public static avio_rl32_delegate avio_rl32;

		public static avio_rl64_delegate avio_rl64;

		public static avio_seek_delegate avio_seek;

		public static avio_seek_time_delegate avio_seek_time;

		public static avio_size_delegate avio_size;

		public static avio_skip_delegate avio_skip;

		public static avio_vprintf_delegate avio_vprintf;

		public static avio_w8_delegate avio_w8;

		public static avio_wb16_delegate avio_wb16;

		public static avio_wb24_delegate avio_wb24;

		public static avio_wb32_delegate avio_wb32;

		public static avio_wb64_delegate avio_wb64;

		public static avio_wl16_delegate avio_wl16;

		public static avio_wl24_delegate avio_wl24;

		public static avio_wl32_delegate avio_wl32;

		public static avio_wl64_delegate avio_wl64;

		public static avio_write_delegate avio_write;

		public static avio_write_marker_delegate avio_write_marker;

		public static avsubtitle_free_delegate avsubtitle_free;

		public static avutil_configuration_delegate avutil_configuration;

		public static avutil_license_delegate avutil_license;

		public static avutil_version_delegate avutil_version;

		public static swr_alloc_delegate swr_alloc;

		public static swr_alloc_set_opts2_delegate swr_alloc_set_opts2;

		public static swr_build_matrix2_delegate swr_build_matrix2;

		public static swr_close_delegate swr_close;

		public static swr_config_frame_delegate swr_config_frame;

		public static swr_convert_delegate swr_convert;

		public static swr_convert_frame_delegate swr_convert_frame;

		public static swr_drop_output_delegate swr_drop_output;

		public static swr_free_delegate swr_free;

		public static swr_get_class_delegate swr_get_class;

		public static swr_get_delay_delegate swr_get_delay;

		public static swr_get_out_samples_delegate swr_get_out_samples;

		public static swr_init_delegate swr_init;

		public static swr_inject_silence_delegate swr_inject_silence;

		public static swr_is_initialized_delegate swr_is_initialized;

		public static swr_next_pts_delegate swr_next_pts;

		public static swr_set_channel_mapping_delegate swr_set_channel_mapping;

		public static swr_set_compensation_delegate swr_set_compensation;

		public static swr_set_matrix_delegate swr_set_matrix;

		public static swresample_configuration_delegate swresample_configuration;

		public static swresample_license_delegate swresample_license;

		public static swresample_version_delegate swresample_version;

		public static sws_alloc_context_delegate sws_alloc_context;

		public static sws_allocVec_delegate sws_allocVec;

		public static sws_convertPalette8ToPacked24_delegate sws_convertPalette8ToPacked24;

		public static sws_convertPalette8ToPacked32_delegate sws_convertPalette8ToPacked32;

		public static sws_frame_end_delegate sws_frame_end;

		public static sws_frame_setup_delegate sws_frame_setup;

		public static sws_frame_start_delegate sws_frame_start;

		public static sws_free_context_delegate sws_free_context;

		public static sws_freeContext_delegate sws_freeContext;

		public static sws_freeFilter_delegate sws_freeFilter;

		public static sws_freeVec_delegate sws_freeVec;

		public static sws_get_class_delegate sws_get_class;

		public static sws_getCachedContext_delegate sws_getCachedContext;

		public static sws_getCoefficients_delegate sws_getCoefficients;

		public static sws_getColorspaceDetails_delegate sws_getColorspaceDetails;

		public static sws_getContext_delegate sws_getContext;

		public static sws_getDefaultFilter_delegate sws_getDefaultFilter;

		public static sws_getGaussianVec_delegate sws_getGaussianVec;

		public static sws_init_context_delegate sws_init_context;

		public static sws_is_noop_delegate sws_is_noop;

		public static sws_isSupportedEndiannessConversion_delegate sws_isSupportedEndiannessConversion;

		public static sws_isSupportedInput_delegate sws_isSupportedInput;

		public static sws_isSupportedOutput_delegate sws_isSupportedOutput;

		public static sws_normalizeVec_delegate sws_normalizeVec;

		public static sws_receive_slice_delegate sws_receive_slice;

		public static sws_receive_slice_alignment_delegate sws_receive_slice_alignment;

		public static sws_scale_delegate sws_scale;

		public static sws_scale_frame_delegate sws_scale_frame;

		public static sws_scaleVec_delegate sws_scaleVec;

		public static sws_send_slice_delegate sws_send_slice;

		public static sws_setColorspaceDetails_delegate sws_setColorspaceDetails;

		public static sws_test_colorspace_delegate sws_test_colorspace;

		public static sws_test_format_delegate sws_test_format;

		public static sws_test_frame_delegate sws_test_frame;

		public static sws_test_primaries_delegate sws_test_primaries;

		public static sws_test_transfer_delegate sws_test_transfer;

		public static swscale_configuration_delegate swscale_configuration;

		public static swscale_license_delegate swscale_license;

		public static swscale_version_delegate swscale_version;
	}
	public interface IFixedArray
	{
		int Length { get; }
	}
	internal interface IFixedArray<T> : IFixedArray
	{
		T this[uint index] { get; set; }

		T[] ToArray();

		void UpdateFrom(T[] array);
	}
	public interface IFunctionResolver
	{
		T GetFunctionDelegate<T>(string libraryName, string functionName, bool throwOnError = true);
	}
	public class UTF8Marshaler : ICustomMarshaler
	{
		private static readonly UTF8Marshaler Instance = new UTF8Marshaler();

		public virtual object MarshalNativeToManaged(IntPtr pNativeData)
		{
			return FromNative(Encoding.UTF8, pNativeData);
		}

		public virtual IntPtr MarshalManagedToNative(object managedObj)
		{
			if (managedObj == null)
			{
				return IntPtr.Zero;
			}
			if (!(managedObj is string value))
			{
				throw new MarshalDirectiveException(GetType().Name + " must be used on a string.");
			}
			return FromManaged(Encoding.UTF8, value);
		}

		public virtual void CleanUpNativeData(IntPtr pNativeData)
		{
			if (pNativeData != IntPtr.Zero)
			{
				Marshal.FreeHGlobal(pNativeData);
			}
		}

		public void CleanUpManagedData(object managedObj)
		{
		}

		public int GetNativeDataSize()
		{
			return -1;
		}

		public static ICustomMarshaler GetInstance(string cookie)
		{
			return Instance;
		}

		public unsafe static string FromNative(Encoding encoding, IntPtr pNativeData)
		{
			return FromNative(encoding, (byte*)(void*)pNativeData);
		}

		public unsafe static string FromNative(Encoding encoding, byte* pNativeData)
		{
			if (pNativeData == null)
			{
				return null;
			}
			byte* ptr;
			for (ptr = pNativeData; *ptr != 0; ptr++)
			{
			}
			if (ptr == pNativeData)
			{
				return string.Empty;
			}
			return new string((sbyte*)pNativeData, 0, (int)(ptr - pNativeData), encoding);
		}

		public unsafe static IntPtr FromManaged(Encoding encoding, string value)
		{
			if (encoding == null || value == null)
			{
				return IntPtr.Zero;
			}
			int byteCount = encoding.GetByteCount(value);
			byte* ptr = (byte*)Marshal.AllocHGlobal(byteCount + 1).ToPointer();
			if (byteCount > 0)
			{
				fixed (char* chars = value)
				{
					encoding.GetBytes(chars, value.Length, ptr, byteCount);
				}
			}
			ptr[byteCount] = 0;
			return new IntPtr(ptr);
		}
	}
}
namespace FFmpeg.AutoGen.Native
{
	public class LinuxFunctionResolver : FunctionResolverBase
	{
		private const string Libdl = "libdl.so.2";

		private const int RTLD_NOW = 2;

		protected override string GetNativeLibraryName(string libraryName, int version)
		{
			return $"lib{libraryName}.so.{version}";
		}

		protected override IntPtr LoadNativeLibrary(string libraryName)
		{
			return dlopen(libraryName, 2);
		}

		protected override IntPtr FindFunctionPointer(IntPtr nativeLibraryHandle, string functionName)
		{
			return dlsym(nativeLibraryHandle, functionName);
		}

		[DllImport("libdl.so.2")]
		public static extern IntPtr dlsym(IntPtr handle, string symbol);

		[DllImport("libdl.so.2")]
		public static extern IntPtr dlopen(string fileName, int flag);
	}
	public class MacFunctionResolver : FunctionResolverBase
	{
		private const string Libdl = "libdl";

		private const int RTLD_NOW = 2;

		protected override string GetNativeLibraryName(string libraryName, int version)
		{
			return $"lib{libraryName}.{version}.dylib";
		}

		protected override IntPtr LoadNativeLibrary(string libraryName)
		{
			return dlopen(libraryName, 2);
		}

		protected override IntPtr FindFunctionPointer(IntPtr nativeLibraryHandle, string functionName)
		{
			return dlsym(nativeLibraryHandle, functionName);
		}

		[DllImport("libdl")]
		public static extern IntPtr dlsym(IntPtr handle, string symbol);

		[DllImport("libdl")]
		public static extern IntPtr dlopen(string fileName, int flag);
	}
	public class WindowsFunctionResolver : FunctionResolverBase
	{
		private const string Kernel32 = "kernel32";

		protected override string GetNativeLibraryName(string libraryName, int version)
		{
			return $"{libraryName}-{version}.dll";
		}

		protected override IntPtr LoadNativeLibrary(string libraryName)
		{
			return LoadLibrary(libraryName);
		}

		protected override IntPtr FindFunctionPointer(IntPtr nativeLibraryHandle, string functionName)
		{
			return GetProcAddress(nativeLibraryHandle, functionName);
		}

		[DllImport("kernel32", BestFitMapping = false, CharSet = CharSet.Ansi)]
		public static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);

		[DllImport("kernel32", SetLastError = true)]
		public static extern IntPtr LoadLibrary(string dllToLoad);
	}
}