[audacity-freeworld/f38] (5 commits) ...fix
by Leigh Scott
Summary of changes:
304d9db... fix (*)
5b445e8... fix (*)
bc48a1e... Revert "fix" (*)
7ea0e5d... Revert "fix" (*)
cff3ad9... fix (*)
(*) This commit already existed in another branch; no separate mail sent
1 year
- 1
- 0
[audacity-freeworld] fix
by Leigh Scott
commit cff3ad958956289b4892890a275fc4ad683fc175
Author: Leigh Scott <leigh123linux(a)gmail.com>
Date: Sat Apr 1 14:38:57 2023 +0100
fix
audacity-freeworld.spec | 7 ++++---
audacity-non-x86.patch | 13 +++++++++++++
2 files changed, 17 insertions(+), 3 deletions(-)
---
diff --git a/audacity-freeworld.spec b/audacity-freeworld.spec
index 86fb3d5..17e97c7 100644
--- a/audacity-freeworld.spec
+++ b/audacity-freeworld.spec
@@ -20,10 +20,11 @@ Source0: https://github.com/audacity/audacity/archive/Audacity-%{version}.tar.gz
# Fix portmidi detection from cmake
Patch0: audacity-2.4.2-fix-portmidi-as-system.patch
# Fix libmp3lame detection from cmake
-Patch1: audacity-2.4.2-fix-libmp3lame-as-system.patch
+Patch1: audacity-2.4.2-fix-libmp3lame-as-system.patch
Patch2: audacity-install-rpath.patch
-Patch3: audacity-3.2.1-compile.patch
-Patch4: https://github.com/audacity/audacity/commit/deaa833a4253699493443e2fee68e...
+Patch3: audacity-non-x86.patch
+Patch4: audacity-3.2.1-compile.patch
+Patch5: https://github.com/audacity/audacity/commit/deaa833a4253699493443e2fee68e...
BuildRequires: cmake
BuildRequires: gettext-devel
diff --git a/audacity-non-x86.patch b/audacity-non-x86.patch
new file mode 100644
index 0000000..cb9fd72
--- /dev/null
+++ b/audacity-non-x86.patch
@@ -0,0 +1,13 @@
+diff -up audacity-sources-3.2.3/cmake-proxies/libsbsms/CMakeLists.txt.omv~ audacity-sources-3.2.3/cmake-proxies/libsbsms/CMakeLists.txt
+--- audacity-sources-3.2.3/cmake-proxies/libsbsms/CMakeLists.txt.omv~ 2022-12-27 22:49:32.131283387 +0000
++++ audacity-sources-3.2.3/cmake-proxies/libsbsms/CMakeLists.txt 2022-12-27 22:58:31.942425724 +0000
+@@ -37,7 +37,7 @@ if( Threads_FOUND AND CMAKE_USE_PTHREADS
+ set( MULTITHREADED 1 )
+ endif()
+
+-if(NOT APPLE OR MACOS_ARCHITECTURE STREQUAL "x86_64")
++if(CMAKE_SYSTEM_PROCESSOR MATCHES "(i.86|x86|X86|x86_64|X86_64|amd64|AMD64)")
+ set( ENABLE_SSE ${HAVE_SSE} )
+ endif()
+
+diff -up audacity-sources-3.2.3/lib-src/libsbsms/src/fft.h.omv~ audacity-sources-3.2.3/lib-src/libsbsms/src/fft.h
1 year
- 1
- 0
[audacity-freeworld] Revert "fix"
by Leigh Scott
commit 7ea0e5db9197b7dc3852f4d13a0f9cac8f644959
Author: Leigh Scott <leigh123linux(a)gmail.com>
Date: Sat Apr 1 14:35:42 2023 +0100
Revert "fix"
This reverts commit 304d9dbd1b4a5706101fcd509935122d5085dcd3.
audacity-freeworld.spec | 5 -----
1 file changed, 5 deletions(-)
---
diff --git a/audacity-freeworld.spec b/audacity-freeworld.spec
index 220675e..86fb3d5 100644
--- a/audacity-freeworld.spec
+++ b/audacity-freeworld.spec
@@ -95,11 +95,6 @@ rm -rf lib-src/{libvamp,libsoxr}/
touch include/RevisionIdent.h
%build
-# fix system lame detection
-export PKG_CONFIG_PATH=$(pwd):$PKG_CONFIG_PATH
-export CFLAGS="%{optflags} -fno-strict-aliasing -ggdb $(wx-config --cflags)"
-export CXXFLAGS="$CFLAGS -std=gnu++11"
-
%cmake \
-DCMAKE_MODULE_LINKER_FLAGS:STRING="$(wx-config --libs)" \
-DCMAKE_SHARED_LINKER_FLAGS:STRING="$(wx-config --libs)" \
1 year
- 1
- 0
[audacity-freeworld] Revert "fix"
by Leigh Scott
commit bc48a1ebd486e125104d04db681686c150b1d8ae
Author: Leigh Scott <leigh123linux(a)gmail.com>
Date: Sat Apr 1 14:35:37 2023 +0100
Revert "fix"
This reverts commit 5b445e83a26e97779a010413a60b690f1458c577.
audacity-freeworld.spec | 9 +++------
1 file changed, 3 insertions(+), 6 deletions(-)
---
diff --git a/audacity-freeworld.spec b/audacity-freeworld.spec
index de84fa6..220675e 100644
--- a/audacity-freeworld.spec
+++ b/audacity-freeworld.spec
@@ -1,9 +1,6 @@
%global __requires_exclude ^lib-audio-devices.so|^lib-basic-ui.so|^lib-components.so|^lib-exceptions.so|^lib-ffmpeg-support.so|^lib-files.so|^lib-math.so|^lib-preferences.so|^lib-project-rate.so|^lib-project.so|^lib-registries.so|^lib-screen-geometry.so|^lib-string-utils.so|^lib-strings.so|^lib-theme.so|^lib-utility.so|^lib-uuid.so|^lib-xml.so|^lib-audio-graph.so|^lib-graphics.so|^lib-ipc.so|^lib-module-manager.so|^lib-project-history.so|^lib-sample-track.so|^lib-theme-resources.so|^lib-track.so|^lib-transactions.so
%global __provides_exclude ^lib-audio-devices.so|^lib-basic-ui.so|^lib-components.so|^lib-exceptions.so|^lib-ffmpeg-support.so|^lib-files.so|^lib-math.so|^lib-preferences.so|^lib-project-rate.so|^lib-project.so|^lib-registries.so|^lib-screen-geometry.so|^lib-string-utils.so|^lib-strings.so|^lib-theme.so|^lib-utility.so|^lib-uuid.so|^lib-xml.so|^lib-audio-graph.so|^lib-graphics.so|^lib-ipc.so|^lib-module-manager.so|^lib-project-history.so|^lib-sample-track.so|^lib-theme-resources.so|^lib-track.so|^lib-transactions.so
-# Disable rpath checking until upstream fixes the rpath: https://github.com/audacity/audacity/issues/1008
-%global __brp_check_rpaths %{nil}
-
%global toolchain clang
Name: audacity-freeworld
@@ -24,8 +21,9 @@ Source0: https://github.com/audacity/audacity/archive/Audacity-%{version}.tar.gz
Patch0: audacity-2.4.2-fix-portmidi-as-system.patch
# Fix libmp3lame detection from cmake
Patch1: audacity-2.4.2-fix-libmp3lame-as-system.patch
-Patch2: audacity-3.2.1-compile.patch
-Patch3: https://github.com/audacity/audacity/commit/deaa833a4253699493443e2fee68e...
+Patch2: audacity-install-rpath.patch
+Patch3: audacity-3.2.1-compile.patch
+Patch4: https://github.com/audacity/audacity/commit/deaa833a4253699493443e2fee68e...
BuildRequires: cmake
BuildRequires: gettext-devel
@@ -97,7 +95,6 @@ rm -rf lib-src/{libvamp,libsoxr}/
touch include/RevisionIdent.h
%build
-
# fix system lame detection
export PKG_CONFIG_PATH=$(pwd):$PKG_CONFIG_PATH
export CFLAGS="%{optflags} -fno-strict-aliasing -ggdb $(wx-config --cflags)"
1 year
- 1
- 0
[audacity-freeworld] fix
by Leigh Scott
commit 5b445e83a26e97779a010413a60b690f1458c577
Author: Leigh Scott <leigh123linux(a)gmail.com>
Date: Sat Apr 1 13:21:26 2023 +0100
fix
audacity-freeworld.spec | 9 ++++++---
1 file changed, 6 insertions(+), 3 deletions(-)
---
diff --git a/audacity-freeworld.spec b/audacity-freeworld.spec
index 220675e..de84fa6 100644
--- a/audacity-freeworld.spec
+++ b/audacity-freeworld.spec
@@ -1,6 +1,9 @@
%global __requires_exclude ^lib-audio-devices.so|^lib-basic-ui.so|^lib-components.so|^lib-exceptions.so|^lib-ffmpeg-support.so|^lib-files.so|^lib-math.so|^lib-preferences.so|^lib-project-rate.so|^lib-project.so|^lib-registries.so|^lib-screen-geometry.so|^lib-string-utils.so|^lib-strings.so|^lib-theme.so|^lib-utility.so|^lib-uuid.so|^lib-xml.so|^lib-audio-graph.so|^lib-graphics.so|^lib-ipc.so|^lib-module-manager.so|^lib-project-history.so|^lib-sample-track.so|^lib-theme-resources.so|^lib-track.so|^lib-transactions.so
%global __provides_exclude ^lib-audio-devices.so|^lib-basic-ui.so|^lib-components.so|^lib-exceptions.so|^lib-ffmpeg-support.so|^lib-files.so|^lib-math.so|^lib-preferences.so|^lib-project-rate.so|^lib-project.so|^lib-registries.so|^lib-screen-geometry.so|^lib-string-utils.so|^lib-strings.so|^lib-theme.so|^lib-utility.so|^lib-uuid.so|^lib-xml.so|^lib-audio-graph.so|^lib-graphics.so|^lib-ipc.so|^lib-module-manager.so|^lib-project-history.so|^lib-sample-track.so|^lib-theme-resources.so|^lib-track.so|^lib-transactions.so
+# Disable rpath checking until upstream fixes the rpath: https://github.com/audacity/audacity/issues/1008
+%global __brp_check_rpaths %{nil}
+
%global toolchain clang
Name: audacity-freeworld
@@ -21,9 +24,8 @@ Source0: https://github.com/audacity/audacity/archive/Audacity-%{version}.tar.gz
Patch0: audacity-2.4.2-fix-portmidi-as-system.patch
# Fix libmp3lame detection from cmake
Patch1: audacity-2.4.2-fix-libmp3lame-as-system.patch
-Patch2: audacity-install-rpath.patch
-Patch3: audacity-3.2.1-compile.patch
-Patch4: https://github.com/audacity/audacity/commit/deaa833a4253699493443e2fee68e...
+Patch2: audacity-3.2.1-compile.patch
+Patch3: https://github.com/audacity/audacity/commit/deaa833a4253699493443e2fee68e...
BuildRequires: cmake
BuildRequires: gettext-devel
@@ -95,6 +97,7 @@ rm -rf lib-src/{libvamp,libsoxr}/
touch include/RevisionIdent.h
%build
+
# fix system lame detection
export PKG_CONFIG_PATH=$(pwd):$PKG_CONFIG_PATH
export CFLAGS="%{optflags} -fno-strict-aliasing -ggdb $(wx-config --cflags)"
1 year
- 1
- 0
[audacity-freeworld] fix
by Leigh Scott
commit 304d9dbd1b4a5706101fcd509935122d5085dcd3
Author: Leigh Scott <leigh123linux(a)gmail.com>
Date: Sat Apr 1 12:56:48 2023 +0100
fix
audacity-freeworld.spec | 5 +++++
1 file changed, 5 insertions(+)
---
diff --git a/audacity-freeworld.spec b/audacity-freeworld.spec
index 86fb3d5..220675e 100644
--- a/audacity-freeworld.spec
+++ b/audacity-freeworld.spec
@@ -95,6 +95,11 @@ rm -rf lib-src/{libvamp,libsoxr}/
touch include/RevisionIdent.h
%build
+# fix system lame detection
+export PKG_CONFIG_PATH=$(pwd):$PKG_CONFIG_PATH
+export CFLAGS="%{optflags} -fno-strict-aliasing -ggdb $(wx-config --cflags)"
+export CXXFLAGS="$CFLAGS -std=gnu++11"
+
%cmake \
-DCMAKE_MODULE_LINKER_FLAGS:STRING="$(wx-config --libs)" \
-DCMAKE_SHARED_LINKER_FLAGS:STRING="$(wx-config --libs)" \
1 year
- 1
- 0
[audacity-freeworld/f38] Add ffmpeg-6 support
by Leigh Scott
Summary of changes:
d5d3d59... Add ffmpeg-6 support (*)
(*) This commit already existed in another branch; no separate mail sent
1 year
- 1
- 0
[audacity-freeworld] Add ffmpeg-6 support
by Leigh Scott
commit d5d3d5932617aaba9fd9c687142bdcecbdb78d50
Author: Leigh Scott <leigh123linux(a)gmail.com>
Date: Sat Apr 1 10:37:23 2023 +0100
Add ffmpeg-6 support
audacity-freeworld.spec | 23 +-
audacity-install-rpath.patch | 68 +
ffmpeg6.patch | 5346 ++++++++++++++++++++++++++++++++++++++++++
3 files changed, 5421 insertions(+), 16 deletions(-)
---
diff --git a/audacity-freeworld.spec b/audacity-freeworld.spec
index ca26f8c..86fb3d5 100644
--- a/audacity-freeworld.spec
+++ b/audacity-freeworld.spec
@@ -1,14 +1,11 @@
%global __requires_exclude ^lib-audio-devices.so|^lib-basic-ui.so|^lib-components.so|^lib-exceptions.so|^lib-ffmpeg-support.so|^lib-files.so|^lib-math.so|^lib-preferences.so|^lib-project-rate.so|^lib-project.so|^lib-registries.so|^lib-screen-geometry.so|^lib-string-utils.so|^lib-strings.so|^lib-theme.so|^lib-utility.so|^lib-uuid.so|^lib-xml.so|^lib-audio-graph.so|^lib-graphics.so|^lib-ipc.so|^lib-module-manager.so|^lib-project-history.so|^lib-sample-track.so|^lib-theme-resources.so|^lib-track.so|^lib-transactions.so
%global __provides_exclude ^lib-audio-devices.so|^lib-basic-ui.so|^lib-components.so|^lib-exceptions.so|^lib-ffmpeg-support.so|^lib-files.so|^lib-math.so|^lib-preferences.so|^lib-project-rate.so|^lib-project.so|^lib-registries.so|^lib-screen-geometry.so|^lib-string-utils.so|^lib-strings.so|^lib-theme.so|^lib-utility.so|^lib-uuid.so|^lib-xml.so|^lib-audio-graph.so|^lib-graphics.so|^lib-ipc.so|^lib-module-manager.so|^lib-project-history.so|^lib-sample-track.so|^lib-theme-resources.so|^lib-track.so|^lib-transactions.so
-# Disable rpath checking until upstream fixes the rpath: https://github.com/audacity/audacity/issues/1008
-%global __brp_check_rpaths %{nil}
-
%global toolchain clang
Name: audacity-freeworld
Version: 3.2.5
-Release: 1%{?dist}
+Release: 2%{?dist}
Summary: Multitrack audio editor
License: GPLv2
URL: https://audacity.sourceforge.net
@@ -24,7 +21,9 @@ Source0: https://github.com/audacity/audacity/archive/Audacity-%{version}.tar.gz
Patch0: audacity-2.4.2-fix-portmidi-as-system.patch
# Fix libmp3lame detection from cmake
Patch1: audacity-2.4.2-fix-libmp3lame-as-system.patch
-Patch2: audacity-3.2.1-compile.patch
+Patch2: audacity-install-rpath.patch
+Patch3: audacity-3.2.1-compile.patch
+Patch4: https://github.com/audacity/audacity/commit/deaa833a4253699493443e2fee68e...
BuildRequires: cmake
BuildRequires: gettext-devel
@@ -70,11 +69,7 @@ BuildRequires: zlib-devel
BuildRequires: python3
BuildRequires: libappstream-glib
-%if 0%{?fedora} < 38
Recommends: ffmpeg-libs
-%else
-Recommends: compat-ffmpeg4
-%endif
# For new symbols in portaudio
Requires: portaudio%{?_isa} >= 19-16
@@ -100,13 +95,6 @@ rm -rf lib-src/{libvamp,libsoxr}/
touch include/RevisionIdent.h
%build
-
-
-# fix system lame detection
-export PKG_CONFIG_PATH=$(pwd):$PKG_CONFIG_PATH
-export CFLAGS="%{optflags} -fno-strict-aliasing -ggdb $(wx-config --cflags)"
-export CXXFLAGS="$CFLAGS -std=gnu++11"
-
%cmake \
-DCMAKE_MODULE_LINKER_FLAGS:STRING="$(wx-config --libs)" \
-DCMAKE_SHARED_LINKER_FLAGS:STRING="$(wx-config --libs)" \
@@ -170,6 +158,9 @@ rm -f %{buildroot}%{_prefix}/%{realname}
%license LICENSE.txt
%changelog
+* Sat Apr 01 2023 Leigh Scott <leigh123linux(a)gmail.com> - 3.2.5-2
+- Add ffmpeg-6 support
+
* Tue Mar 14 2023 Leigh Scott <leigh123linux(a)gmail.com> - 3.2.5-1
- 3.2.5
- Use clang
diff --git a/audacity-install-rpath.patch b/audacity-install-rpath.patch
new file mode 100644
index 0000000..4532601
--- /dev/null
+++ b/audacity-install-rpath.patch
@@ -0,0 +1,68 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 3aa5ef8..f3b3d53 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -397,7 +397,7 @@ set( _EXEDIR "${_DEST}" )
+ # Setup RPATH handling
+ set( CMAKE_BUILD_RPATH "${_DEST}/${_PKGLIB}" )
+ set( CMAKE_BUILD_WITH_INSTALL_RPATH FALSE )
+-set( CMAKE_INSTALL_RPATH "$ORIGIN/../${_PKGLIB}" )
++set( CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_FULL_LIBDIR}/audacity" )
+ set( CMAKE_INSTALL_RPATH_USE_LINK_PATH FALSE )
+
+ # Adjust them for the Mac
+diff --git a/scripts/build/linux/fix_rpath.cmake b/scripts/build/linux/fix_rpath.cmake
+index ed23f2b..6036f6b 100644
+--- a/scripts/build/linux/fix_rpath.cmake
++++ b/scripts/build/linux/fix_rpath.cmake
+@@ -6,7 +6,7 @@ set(private_lib_dir "${install_dir}/${_LIBDIR}/audacity")
+
+ message(STATUS "Running fix_rpath in ${private_lib_dir}")
+
+-file(GLOB libs LIST_DIRECTORIES Off "${private_lib_dir}/*.so*")
++file(GLOB_RECURSE libs LIST_DIRECTORIES Off "${private_lib_dir}/*.so*")
+
+ function(get_rpath outvar lib)
+ execute_process(
+@@ -47,11 +47,11 @@ foreach(lib ${libs})
+ get_rpath(current_rpath ${lib})
+
+ if( current_rpath )
+- if(NOT current_rpath STREQUAL "$ORIGIN")
++ if(NOT current_rpath STREQUAL "${_PKGLIB}")
+ file(RPATH_CHANGE
+ FILE "${lib}"
+ OLD_RPATH "${current_rpath}"
+- NEW_RPATH "$ORIGIN")
++ NEW_RPATH "${_PKGLIB}")
+ endif()
+ else()
+ message(STATUS "\tNo rpath was set")
+diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
+index 7b90c1b..942dffb 100644
+--- a/src/CMakeLists.txt
++++ b/src/CMakeLists.txt
+@@ -1630,6 +1630,7 @@ else()
+ FILES_MATCHING PATTERN "*.so*" )
+
+ install( CODE "set( _LIBDIR \"${_LIBDIR}\")" )
++ install( CODE "set( _PKGLIB \"${CMAKE_INSTALL_FULL_LIBDIR}/audacity\")" )
+ install( SCRIPT "${CMAKE_SOURCE_DIR}/scripts/build/linux/fix_rpath.cmake" )
+
+ install( FILES "${_INTDIR}/audacity.desktop"
+diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
+index d464383..0da2a9c 100644
+--- a/modules/CMakeLists.txt
++++ b/modules/CMakeLists.txt
+@@ -20,6 +20,11 @@ if( NOT CMAKE_SYSTEM_NAME MATCHES "Darwin" )
+ if( NOT "${CMAKE_GENERATOR}" MATCHES "Visual Studio*")
+ install( DIRECTORY "${_DEST}/modules"
+ DESTINATION "${_PKGLIB}" )
++
++ install( CODE "set( _LIBDIR \"${_LIBDIR}\")" )
++ install( CODE "set( _PKGLIB \"${CMAKE_INSTALL_FULL_LIBDIR}/audacity\")" )
++ install( SCRIPT "${CMAKE_SOURCE_DIR}/scripts/build/linux/fix_rpath.cmake" )
++
+ endif()
+ endif()
+
diff --git a/ffmpeg6.patch b/ffmpeg6.patch
new file mode 100644
index 0000000..12e00b5
--- /dev/null
+++ b/ffmpeg6.patch
@@ -0,0 +1,5346 @@
+From 451b303e2ba3c0d84fbf281fdd955d618474c4dc Mon Sep 17 00:00:00 2001
+From: Dmitry Vedenko <dmitry(a)crsib.me>
+Date: Thu, 16 Mar 2023 17:42:46 +0300
+Subject: [PATCH 1/3] Adds FFmpeg 6.0 header file
+
+---
+ .../impl/ffmpeg-6.0.0-single-header.h | 5058 +++++++++++++++++
+ 1 file changed, 5058 insertions(+)
+ create mode 100644 libraries/lib-ffmpeg-support/impl/ffmpeg-6.0.0-single-header.h
+
+diff --git a/libraries/lib-ffmpeg-support/impl/ffmpeg-6.0.0-single-header.h b/libraries/lib-ffmpeg-support/impl/ffmpeg-6.0.0-single-header.h
+new file mode 100644
+index 00000000000..3e3a7cb1cc2
+--- /dev/null
++++ b/libraries/lib-ffmpeg-support/impl/ffmpeg-6.0.0-single-header.h
+@@ -0,0 +1,5058 @@
++// This header was generated from the FFMPEG headers
++#pragma once
++
++#include <string.h>
++#include <math.h>
++#include <time.h>
++#include <stddef.h>
++#include <limits.h>
++#include <errno.h>
++#include <stdlib.h>
++#include <inttypes.h>
++#include <stdint.h>
++#include <stdio.h>
++#include <stdarg.h>
++
++#define AVCODEC_AVCODEC_H
++
++#define AVUTIL_SAMPLEFMT_H
++
++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
++};
++
++const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt);
++
++enum AVSampleFormat av_get_sample_fmt(const char *name);
++
++enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar);
++
++enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt);
++
++enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt);
++
++char *av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt);
++
++int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt);
++
++int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt);
++
++int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
++ enum AVSampleFormat sample_fmt, int align);
++
++int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
++ const uint8_t *buf,
++ int nb_channels, int nb_samples,
++ enum AVSampleFormat sample_fmt, int align);
++
++int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
++ int nb_samples, enum AVSampleFormat sample_fmt, int align);
++
++int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels,
++ int nb_samples, enum AVSampleFormat sample_fmt, int align);
++
++int av_samples_copy(uint8_t **dst, uint8_t * const *src, int dst_offset,
++ int src_offset, int nb_samples, int nb_channels,
++ enum AVSampleFormat sample_fmt);
++
++int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples,
++ int nb_channels, enum AVSampleFormat sample_fmt);
++
++#define AVUTIL_ATTRIBUTES_H
++
++# define AV_GCC_VERSION_AT_LEAST(x,y) 0
++# define AV_GCC_VERSION_AT_MOST(x,y) 0
++
++# define AV_HAS_BUILTIN(x) 0
++
++# define av_always_inline inline
++
++# define av_extern_inline inline
++
++# define av_warn_unused_result
++
++# define av_noinline
++
++# define av_pure
++
++# define av_const
++
++# define av_cold
++
++# define av_flatten
++
++# define attribute_deprecated
++
++# define AV_NOWARN_DEPRECATED(code) code
++
++# define av_unused
++
++# define av_used
++
++# define av_alias
++
++# define av_uninit(x) x
++
++# define av_builtin_constant_p(x) 0
++# define av_printf_format(fmtpos, attrpos)
++
++# define av_noreturn
++
++#define AVUTIL_AVUTIL_H
++
++unsigned avutil_version(void);
++
++const char *av_version_info(void);
++
++const char *avutil_configuration(void);
++
++const char *avutil_license(void);
++
++enum AVMediaType {
++ AVMEDIA_TYPE_UNKNOWN = -1,
++ AVMEDIA_TYPE_VIDEO,
++ AVMEDIA_TYPE_AUDIO,
++ AVMEDIA_TYPE_DATA,
++ AVMEDIA_TYPE_SUBTITLE,
++ AVMEDIA_TYPE_ATTACHMENT,
++ AVMEDIA_TYPE_NB
++};
++
++const char *av_get_media_type_string(enum AVMediaType media_type);
++
++#define FF_LAMBDA_SHIFT 7
++#define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT)
++#define FF_QP2LAMBDA 118
++#define FF_LAMBDA_MAX (256*128-1)
++
++#define FF_QUALITY_SCALE FF_LAMBDA_SCALE
++
++#define AV_NOPTS_VALUE ((int64_t)UINT64_C(0x8000000000000000))
++
++#define AV_TIME_BASE 1000000
++
++#define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE}
++
++enum AVPictureType {
++ AV_PICTURE_TYPE_NONE = 0,
++ 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,
++};
++
++char av_get_picture_type_char(enum AVPictureType pict_type);
++
++#define AVUTIL_COMMON_H
++
++#define AVUTIL_MACROS_H
++
++# define AV_NE(be, le) (le)
++
++#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
++
++#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
++#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
++#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
++#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
++
++#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
++#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
++
++#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
++#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
++
++#define AV_STRINGIFY(s) AV_TOSTRING(s)
++#define AV_TOSTRING(s) #s
++
++#define AV_GLUE(a, b) a ## b
++#define AV_JOIN(a, b) AV_GLUE(a, b)
++
++#define AV_PRAGMA(s) _Pragma(#s)
++
++#define FFALIGN(x, a) (((x)+(a)-1)&~((a)-1))
++
++#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
++
++#define ROUNDED_DIV(a,b) (((a)>=0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
++
++#define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
++ : ((a) + (1<<(b)) - 1) >> (b))
++
++#define FF_CEIL_RSHIFT AV_CEIL_RSHIFT
++
++#define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b))
++#define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b))
++
++#define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
++#define FFSIGN(a) ((a) > 0 ? 1 : -1)
++
++#define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
++
++#define FFABSU(a) ((a) <= 0 ? -(unsigned)(a) : (unsigned)(a))
++#define FFABS64U(a) ((a) <= 0 ? -(uint64_t)(a) : (uint64_t)(a))
++
++# define av_ceil_log2 av_ceil_log2_c
++# define av_clip av_clip_c
++# define av_clip64 av_clip64_c
++# define av_clip_uint8 av_clip_uint8_c
++# define av_clip_int8 av_clip_int8_c
++# define av_clip_uint16 av_clip_uint16_c
++# define av_clip_int16 av_clip_int16_c
++# define av_clipl_int32 av_clipl_int32_c
++# define av_clip_intp2 av_clip_intp2_c
++# define av_clip_uintp2 av_clip_uintp2_c
++# define av_mod_uintp2 av_mod_uintp2_c
++# define av_sat_add32 av_sat_add32_c
++# define av_sat_dadd32 av_sat_dadd32_c
++# define av_sat_sub32 av_sat_sub32_c
++# define av_sat_dsub32 av_sat_dsub32_c
++# define av_sat_add64 av_sat_add64_c
++# define av_sat_sub64 av_sat_sub64_c
++# define av_clipf av_clipf_c
++# define av_clipd av_clipd_c
++# define av_popcount av_popcount_c
++# define av_popcount64 av_popcount64_c
++# define av_parity av_parity_c
++
++av_const int av_log2(unsigned v);
++
++av_const int av_log2_16bit(unsigned v);
++
++static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
++{
++ if (a < amin) return amin;
++ else if (a > amax) return amax;
++ else return a;
++}
++
++static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax)
++{
++ if (a < amin) return amin;
++ else if (a > amax) return amax;
++ else return a;
++}
++
++static av_always_inline av_const uint8_t av_clip_uint8_c(int a)
++{
++ if (a&(~0xFF)) return (~a)>>31;
++ else return a;
++}
++
++static av_always_inline av_const int8_t av_clip_int8_c(int a)
++{
++ if ((a+0x80U) & ~0xFF) return (a>>31) ^ 0x7F;
++ else return a;
++}
++
++static av_always_inline av_const uint16_t av_clip_uint16_c(int a)
++{
++ if (a&(~0xFFFF)) return (~a)>>31;
++ else return a;
++}
++
++static av_always_inline av_const int16_t av_clip_int16_c(int a)
++{
++ if ((a+0x8000U) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
++ else return a;
++}
++
++static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a)
++{
++ if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF);
++ else return (int32_t)a;
++}
++
++static av_always_inline av_const int av_clip_intp2_c(int a, int p)
++{
++ if (((unsigned)a + (1 << p)) & ~((2 << p) - 1))
++ return (a >> 31) ^ ((1 << p) - 1);
++ else
++ return a;
++}
++
++static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
++{
++ if (a & ~((1<<p) - 1)) return (~a) >> 31 & ((1<<p) - 1);
++ else return a;
++}
++
++static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
++{
++ return a & ((1U << p) - 1);
++}
++
++static av_always_inline int av_sat_add32_c(int a, int b)
++{
++ return av_clipl_int32((int64_t)a + b);
++}
++
++static av_always_inline int av_sat_dadd32_c(int a, int b)
++{
++ return av_sat_add32(a, av_sat_add32(b, b));
++}
++
++static av_always_inline int av_sat_sub32_c(int a, int b)
++{
++ return av_clipl_int32((int64_t)a - b);
++}
++
++static av_always_inline int av_sat_dsub32_c(int a, int b)
++{
++ return av_sat_sub32(a, av_sat_add32(b, b));
++}
++
++static av_always_inline int64_t av_sat_add64_c(int64_t a, int64_t b) {
++ int64_t s = a+(uint64_t)b;
++ if ((int64_t)(a^b | ~s^b) >= 0)
++ return INT64_MAX ^ (b >> 63);
++ return s;
++}
++
++static av_always_inline int64_t av_sat_sub64_c(int64_t a, int64_t b) {
++ if (b <= 0 && a >= INT64_MAX + b)
++ return INT64_MAX;
++ if (b >= 0 && a <= INT64_MIN + b)
++ return INT64_MIN;
++ return a - b;
++}
++
++static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
++{
++ return FFMIN(FFMAX(a, amin), amax);
++}
++
++static av_always_inline av_const double av_clipd_c(double a, double amin, double amax)
++{
++ return FFMIN(FFMAX(a, amin), amax);
++}
++
++static av_always_inline av_const int av_ceil_log2_c(int x)
++{
++ return av_log2((x - 1U) << 1);
++}
++
++static av_always_inline av_const int av_popcount_c(uint32_t x)
++{
++ x -= (x >> 1) & 0x55555555;
++ x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
++ x = (x + (x >> 4)) & 0x0F0F0F0F;
++ x += x >> 8;
++ return (x + (x >> 16)) & 0x3F;
++}
++
++static av_always_inline av_const int av_popcount64_c(uint64_t x)
++{
++ return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32));
++}
++
++static av_always_inline av_const int av_parity_c(uint32_t v)
++{
++ return av_popcount(v) & 1;
++}
++
++#define GET_UTF8(val, GET_BYTE, ERROR)\
++ val= (GET_BYTE);\
++ {\
++ uint32_t top = (val & 128) >> 1;\
++ if ((val & 0xc0) == 0x80 || val >= 0xFE)\
++ {ERROR}\
++ while (val & top) {\
++ unsigned int tmp = (GET_BYTE) - 128;\
++ if(tmp>>6)\
++ {ERROR}\
++ val= (val<<6) + tmp;\
++ top <<= 5;\
++ }\
++ val &= (top << 1) - 1;\
++ }
++
++#define GET_UTF16(val, GET_16BIT, ERROR)\
++ val = (GET_16BIT);\
++ {\
++ unsigned int hi = val - 0xD800;\
++ if (hi < 0x800) {\
++ val = (GET_16BIT) - 0xDC00;\
++ if (val > 0x3FFU || hi > 0x3FFU)\
++ {ERROR}\
++ val += (hi<<10) + 0x10000;\
++ }\
++ }\
++
++#define PUT_UTF8(val, tmp, PUT_BYTE)\
++ {\
++ int bytes, shift;\
++ uint32_t in = val;\
++ if (in < 0x80) {\
++ tmp = in;\
++ PUT_BYTE\
++ } else {\
++ bytes = (av_log2(in) + 4) / 5;\
++ shift = (bytes - 1) * 6;\
++ tmp = (256 - (256 >> bytes)) | (in >> shift);\
++ PUT_BYTE\
++ while (shift >= 6) {\
++ shift -= 6;\
++ tmp = 0x80 | ((in >> shift) & 0x3f);\
++ PUT_BYTE\
++ }\
++ }\
++ }
++
++#define PUT_UTF16(val, tmp, PUT_16BIT)\
++ {\
++ uint32_t in = val;\
++ if (in < 0x10000) {\
++ tmp = in;\
++ PUT_16BIT\
++ } else {\
++ tmp = 0xD800 | ((in - 0x10000) >> 10);\
++ PUT_16BIT\
++ tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
++ PUT_16BIT\
++ }\
++ }\
++
++#define AVUTIL_MEM_H
++
++#define AVUTIL_VERSION_H
++
++#define AV_VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c))
++#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
++#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
++
++#define AV_VERSION_MAJOR(a) ((a) >> 16)
++#define AV_VERSION_MINOR(a) (((a) & 0x00FF00) >> 8)
++#define AV_VERSION_MICRO(a) ((a) & 0xFF)
++
++#define LIBAVUTIL_VERSION_MAJOR 58
++#define LIBAVUTIL_VERSION_MINOR 2
++#define LIBAVUTIL_VERSION_MICRO 100
++
++#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
++ LIBAVUTIL_VERSION_MINOR, \
++ LIBAVUTIL_VERSION_MICRO)
++#define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \
++ LIBAVUTIL_VERSION_MINOR, \
++ LIBAVUTIL_VERSION_MICRO)
++#define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT
++
++#define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)
++
++#define FF_API_FIFO_PEEK2 (LIBAVUTIL_VERSION_MAJOR < 59)
++#define FF_API_FIFO_OLD_API (LIBAVUTIL_VERSION_MAJOR < 59)
++#define FF_API_XVMC (LIBAVUTIL_VERSION_MAJOR < 59)
++#define FF_API_OLD_CHANNEL_LAYOUT (LIBAVUTIL_VERSION_MAJOR < 59)
++#define FF_API_AV_FOPEN_UTF8 (LIBAVUTIL_VERSION_MAJOR < 59)
++#define FF_API_PKT_DURATION (LIBAVUTIL_VERSION_MAJOR < 59)
++#define FF_API_REORDERED_OPAQUE (LIBAVUTIL_VERSION_MAJOR < 59)
++#define FF_API_FRAME_PICTURE_NUMBER (LIBAVUTIL_VERSION_MAJOR < 59)
++
++ #define av_malloc_attrib
++
++ #define av_alloc_size(...)
++
++void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
++
++void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
++
++av_alloc_size(1, 2) void *av_malloc_array(size_t nmemb, size_t size);
++
++void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2);
++
++void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
++
++av_warn_unused_result
++int av_reallocp(void *ptr, size_t size);
++
++void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
++
++av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
++
++int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
++
++void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size);
++
++void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
++
++void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size);
++
++void av_free(void *ptr);
++
++void av_freep(void *ptr);
++
++char *av_strdup(const char *s) av_malloc_attrib;
++
++char *av_strndup(const char *s, size_t len) av_malloc_attrib;
++
++void *av_memdup(const void *p, size_t size);
++
++void av_memcpy_backptr(uint8_t *dst, int back, int cnt);
++
++void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
++
++av_warn_unused_result
++int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem);
++
++void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
++ const uint8_t *elem_data);
++
++int av_size_mult(size_t a, size_t b, size_t *r);
++
++void av_max_alloc(size_t max);
++
++#define AVUTIL_ERROR_H
++
++#define AVERROR(e) (e)
++#define AVUNERROR(e) (e)
++
++#define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d))
++
++#define AVERROR_BSF_NOT_FOUND FFERRTAG(0xF8,'B','S','F')
++#define AVERROR_BUG FFERRTAG( 'B','U','G','!')
++#define AVERROR_BUFFER_TOO_SMALL FFERRTAG( 'B','U','F','S')
++#define AVERROR_DECODER_NOT_FOUND FFERRTAG(0xF8,'D','E','C')
++#define AVERROR_DEMUXER_NOT_FOUND FFERRTAG(0xF8,'D','E','M')
++#define AVERROR_ENCODER_NOT_FOUND FFERRTAG(0xF8,'E','N','C')
++#define AVERROR_EOF FFERRTAG( 'E','O','F',' ')
++#define AVERROR_EXIT FFERRTAG( 'E','X','I','T')
++#define AVERROR_EXTERNAL FFERRTAG( 'E','X','T',' ')
++#define AVERROR_FILTER_NOT_FOUND FFERRTAG(0xF8,'F','I','L')
++#define AVERROR_INVALIDDATA FFERRTAG( 'I','N','D','A')
++#define AVERROR_MUXER_NOT_FOUND FFERRTAG(0xF8,'M','U','X')
++#define AVERROR_OPTION_NOT_FOUND FFERRTAG(0xF8,'O','P','T')
++#define AVERROR_PATCHWELCOME FFERRTAG( 'P','A','W','E')
++#define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O')
++
++#define AVERROR_STREAM_NOT_FOUND FFERRTAG(0xF8,'S','T','R')
++
++#define AVERROR_BUG2 FFERRTAG( 'B','U','G',' ')
++#define AVERROR_UNKNOWN FFERRTAG( 'U','N','K','N')
++#define AVERROR_EXPERIMENTAL (-0x2bb2afa8)
++#define AVERROR_INPUT_CHANGED (-0x636e6701)
++#define AVERROR_OUTPUT_CHANGED (-0x636e6702)
++
++#define AVERROR_HTTP_BAD_REQUEST FFERRTAG(0xF8,'4','0','0')
++#define AVERROR_HTTP_UNAUTHORIZED FFERRTAG(0xF8,'4','0','1')
++#define AVERROR_HTTP_FORBIDDEN FFERRTAG(0xF8,'4','0','3')
++#define AVERROR_HTTP_NOT_FOUND FFERRTAG(0xF8,'4','0','4')
++#define AVERROR_HTTP_OTHER_4XX FFERRTAG(0xF8,'4','X','X')
++#define AVERROR_HTTP_SERVER_ERROR FFERRTAG(0xF8,'5','X','X')
++
++#define AV_ERROR_MAX_STRING_SIZE 64
++
++int av_strerror(int errnum, char *errbuf, size_t errbuf_size);
++
++static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum)
++{
++ av_strerror(errnum, errbuf, errbuf_size);
++ return errbuf;
++}
++
++#define av_err2str(errnum) \
++ av_make_error_string((char[AV_ERROR_MAX_STRING_SIZE]){0}, AV_ERROR_MAX_STRING_SIZE, errnum)
++
++#define AVUTIL_RATIONAL_H
++
++typedef struct AVRational{
++ int num;
++ int den;
++} AVRational;
++
++static inline AVRational av_make_q(int num, int den)
++{
++ AVRational r = { num, den };
++ return r;
++}
++
++static inline int av_cmp_q(AVRational a, AVRational b){
++ const int64_t tmp= a.num * (int64_t)b.den - b.num * (int64_t)a.den;
++
++ if(tmp) return (int)((tmp ^ a.den ^ b.den)>>63)|1;
++ else if(b.den && a.den) return 0;
++ else if(a.num && b.num) return (a.num>>31) - (b.num>>31);
++ else return INT_MIN;
++}
++
++static inline double av_q2d(AVRational a){
++ return a.num / (double) a.den;
++}
++
++int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max);
++
++AVRational av_mul_q(AVRational b, AVRational c) av_const;
++
++AVRational av_div_q(AVRational b, AVRational c) av_const;
++
++AVRational av_add_q(AVRational b, AVRational c) av_const;
++
++AVRational av_sub_q(AVRational b, AVRational c) av_const;
++
++static av_always_inline AVRational av_inv_q(AVRational q)
++{
++ AVRational r = { q.den, q.num };
++ return r;
++}
++
++AVRational av_d2q(double d, int max) av_const;
++
++int av_nearer_q(AVRational q, AVRational q1, AVRational q2);
++
++int av_find_nearest_q_idx(AVRational q, const AVRational* q_list);
++
++uint32_t av_q2intfloat(AVRational q);
++
++AVRational av_gcd_q(AVRational a, AVRational b, int max_den, AVRational def);
++
++#define AVUTIL_MATHEMATICS_H
++
++#define AVUTIL_INTFLOAT_H
++
++union av_intfloat32 {
++ uint32_t i;
++ float f;
++};
++
++union av_intfloat64 {
++ uint64_t i;
++ double f;
++};
++
++static av_always_inline float av_int2float(uint32_t i)
++{
++ union av_intfloat32 v;
++ v.i = i;
++ return v.f;
++}
++
++static av_always_inline uint32_t av_float2int(float f)
++{
++ union av_intfloat32 v;
++ v.f = f;
++ return v.i;
++}
++
++static av_always_inline double av_int2double(uint64_t i)
++{
++ union av_intfloat64 v;
++ v.i = i;
++ return v.f;
++}
++
++static av_always_inline uint64_t av_double2int(double f)
++{
++ union av_intfloat64 v;
++ v.f = f;
++ return v.i;
++}
++
++#define M_E 2.7182818284590452354
++#define M_LN2 0.69314718055994530942
++#define M_LN10 2.30258509299404568402
++#define M_LOG2_10 3.32192809488736234787
++#define M_PHI 1.61803398874989484820
++#define M_PI 3.14159265358979323846
++#define M_PI_2 1.57079632679489661923
++#define M_SQRT1_2 0.70710678118654752440
++#define M_SQRT2 1.41421356237309504880
++#define NAN av_int2float(0x7fc00000)
++#define INFINITY av_int2float(0x7f800000)
++
++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,
++};
++
++int64_t av_const av_gcd(int64_t a, int64_t b);
++
++int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
++
++int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd) av_const;
++
++int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
++
++int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
++ enum AVRounding rnd) av_const;
++
++int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
++
++int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod);
++
++int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb);
++
++int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc);
++
++#define AVUTIL_LOG_H
++
++typedef enum {
++ AV_CLASS_CATEGORY_NA = 0,
++ AV_CLASS_CATEGORY_INPUT,
++ AV_CLASS_CATEGORY_OUTPUT,
++ AV_CLASS_CATEGORY_MUXER,
++ AV_CLASS_CATEGORY_DEMUXER,
++ AV_CLASS_CATEGORY_ENCODER,
++ AV_CLASS_CATEGORY_DECODER,
++ AV_CLASS_CATEGORY_FILTER,
++ AV_CLASS_CATEGORY_BITSTREAM_FILTER,
++ AV_CLASS_CATEGORY_SWSCALER,
++ AV_CLASS_CATEGORY_SWRESAMPLER,
++ AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = 40,
++ AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
++ AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT,
++ AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT,
++ AV_CLASS_CATEGORY_DEVICE_OUTPUT,
++ AV_CLASS_CATEGORY_DEVICE_INPUT,
++ AV_CLASS_CATEGORY_NB
++}AVClassCategory;
++
++#define AV_IS_INPUT_DEVICE(category) \
++ (((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT) || \
++ ((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT) || \
++ ((category) == AV_CLASS_CATEGORY_DEVICE_INPUT))
++
++#define AV_IS_OUTPUT_DEVICE(category) \
++ (((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT) || \
++ ((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT) || \
++ ((category) == AV_CLASS_CATEGORY_DEVICE_OUTPUT))
++
++struct AVOptionRanges;
++
++typedef struct AVClass {
++
++ const char* class_name;
++
++ const char* (*item_name)(void* ctx);
++
++ const struct AVOption *option;
++
++ int version;
++
++ int log_level_offset_offset;
++
++ int parent_log_context_offset;
++
++ AVClassCategory category;
++
++ AVClassCategory (*get_category)(void* ctx);
++
++ int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags);
++
++ void* (*child_next)(void *obj, void *prev);
++
++ const struct AVClass* (*child_class_iterate)(void **iter);
++} AVClass;
++
++#define AV_LOG_QUIET -8
++
++#define AV_LOG_PANIC 0
++
++#define AV_LOG_FATAL 8
++
++#define AV_LOG_ERROR 16
++
++#define AV_LOG_WARNING 24
++
++#define AV_LOG_INFO 32
++
++#define AV_LOG_VERBOSE 40
++
++#define AV_LOG_DEBUG 48
++
++#define AV_LOG_TRACE 56
++
++#define AV_LOG_MAX_OFFSET (AV_LOG_TRACE - AV_LOG_QUIET)
++
++#define AV_LOG_C(x) ((x) << 8)
++
++void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
++
++void av_log_once(void* avcl, int initial_level, int subsequent_level, int *state, const char *fmt, ...) av_printf_format(5, 6);
++
++void av_vlog(void *avcl, int level, const char *fmt, va_list vl);
++
++int av_log_get_level(void);
++
++void av_log_set_level(int level);
++
++void av_log_set_callback(void (*callback)(void*, int, const char*, va_list));
++
++void av_log_default_callback(void *avcl, int level, const char *fmt,
++ va_list vl);
++
++const char* av_default_item_name(void* ctx);
++AVClassCategory av_default_get_category(void *ptr);
++
++void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
++ char *line, int line_size, int *print_prefix);
++
++int av_log_format_line2(void *ptr, int level, const char *fmt, va_list vl,
++ char *line, int line_size, int *print_prefix);
++
++#define AV_LOG_SKIP_REPEATED 1
++
++#define AV_LOG_PRINT_LEVEL 2
++
++void av_log_set_flags(int arg);
++int av_log_get_flags(void);
++
++#define AVUTIL_PIXFMT_H
++
++#define AVPALETTE_SIZE 1024
++#define AVPALETTE_COUNT 256
++
++enum AVPixelFormat {
++ AV_PIX_FMT_NONE = -1,
++ AV_PIX_FMT_YUV420P,
++ AV_PIX_FMT_YUYV422,
++ AV_PIX_FMT_RGB24,
++ AV_PIX_FMT_BGR24,
++ AV_PIX_FMT_YUV422P,
++ AV_PIX_FMT_YUV444P,
++ AV_PIX_FMT_YUV410P,
++ AV_PIX_FMT_YUV411P,
++ AV_PIX_FMT_GRAY8,
++ AV_PIX_FMT_MONOWHITE,
++ AV_PIX_FMT_MONOBLACK,
++ AV_PIX_FMT_PAL8,
++ AV_PIX_FMT_YUVJ420P,
++ AV_PIX_FMT_YUVJ422P,
++ AV_PIX_FMT_YUVJ444P,
++ AV_PIX_FMT_UYVY422,
++ AV_PIX_FMT_UYYVYY411,
++ AV_PIX_FMT_BGR8,
++ AV_PIX_FMT_BGR4,
++ AV_PIX_FMT_BGR4_BYTE,
++ AV_PIX_FMT_RGB8,
++ AV_PIX_FMT_RGB4,
++ AV_PIX_FMT_RGB4_BYTE,
++ AV_PIX_FMT_NV12,
++ AV_PIX_FMT_NV21,
++
++ AV_PIX_FMT_ARGB,
++ AV_PIX_FMT_RGBA,
++ AV_PIX_FMT_ABGR,
++ AV_PIX_FMT_BGRA,
++
++ AV_PIX_FMT_GRAY16BE,
++ AV_PIX_FMT_GRAY16LE,
++ AV_PIX_FMT_YUV440P,
++ AV_PIX_FMT_YUVJ440P,
++ AV_PIX_FMT_YUVA420P,
++ AV_PIX_FMT_RGB48BE,
++ AV_PIX_FMT_RGB48LE,
++
++ AV_PIX_FMT_RGB565BE,
++ AV_PIX_FMT_RGB565LE,
++ AV_PIX_FMT_RGB555BE,
++ AV_PIX_FMT_RGB555LE,
++
++ AV_PIX_FMT_BGR565BE,
++ AV_PIX_FMT_BGR565LE,
++ AV_PIX_FMT_BGR555BE,
++ AV_PIX_FMT_BGR555LE,
++
++ AV_PIX_FMT_VAAPI,
++
++ AV_PIX_FMT_YUV420P16LE,
++ AV_PIX_FMT_YUV420P16BE,
++ AV_PIX_FMT_YUV422P16LE,
++ AV_PIX_FMT_YUV422P16BE,
++ AV_PIX_FMT_YUV444P16LE,
++ AV_PIX_FMT_YUV444P16BE,
++ AV_PIX_FMT_DXVA2_VLD,
++
++ AV_PIX_FMT_RGB444LE,
++ AV_PIX_FMT_RGB444BE,
++ AV_PIX_FMT_BGR444LE,
++ AV_PIX_FMT_BGR444BE,
++ AV_PIX_FMT_YA8,
++
++ AV_PIX_FMT_Y400A = AV_PIX_FMT_YA8,
++ AV_PIX_FMT_GRAY8A= AV_PIX_FMT_YA8,
++
++ AV_PIX_FMT_BGR48BE,
++ AV_PIX_FMT_BGR48LE,
++
++ AV_PIX_FMT_YUV420P9BE,
++ AV_PIX_FMT_YUV420P9LE,
++ AV_PIX_FMT_YUV420P10BE,
++ AV_PIX_FMT_YUV420P10LE,
++ AV_PIX_FMT_YUV422P10BE,
++ AV_PIX_FMT_YUV422P10LE,
++ AV_PIX_FMT_YUV444P9BE,
++ AV_PIX_FMT_YUV444P9LE,
++ AV_PIX_FMT_YUV444P10BE,
++ AV_PIX_FMT_YUV444P10LE,
++ AV_PIX_FMT_YUV422P9BE,
++ AV_PIX_FMT_YUV422P9LE,
++ AV_PIX_FMT_GBRP,
++ AV_PIX_FMT_GBR24P = AV_PIX_FMT_GBRP,
++ AV_PIX_FMT_GBRP9BE,
++ AV_PIX_FMT_GBRP9LE,
++ AV_PIX_FMT_GBRP10BE,
++ AV_PIX_FMT_GBRP10LE,
++ AV_PIX_FMT_GBRP16BE,
++ AV_PIX_FMT_GBRP16LE,
++ AV_PIX_FMT_YUVA422P,
++ AV_PIX_FMT_YUVA444P,
++ AV_PIX_FMT_YUVA420P9BE,
++ AV_PIX_FMT_YUVA420P9LE,
++ AV_PIX_FMT_YUVA422P9BE,
++ AV_PIX_FMT_YUVA422P9LE,
++ AV_PIX_FMT_YUVA444P9BE,
++ AV_PIX_FMT_YUVA444P9LE,
++ AV_PIX_FMT_YUVA420P10BE,
++ AV_PIX_FMT_YUVA420P10LE,
++ AV_PIX_FMT_YUVA422P10BE,
++ AV_PIX_FMT_YUVA422P10LE,
++ AV_PIX_FMT_YUVA444P10BE,
++ AV_PIX_FMT_YUVA444P10LE,
++ AV_PIX_FMT_YUVA420P16BE,
++ AV_PIX_FMT_YUVA420P16LE,
++ AV_PIX_FMT_YUVA422P16BE,
++ AV_PIX_FMT_YUVA422P16LE,
++ AV_PIX_FMT_YUVA444P16BE,
++ AV_PIX_FMT_YUVA444P16LE,
++
++ AV_PIX_FMT_VDPAU,
++
++ AV_PIX_FMT_XYZ12LE,
++ AV_PIX_FMT_XYZ12BE,
++ AV_PIX_FMT_NV16,
++ AV_PIX_FMT_NV20LE,
++ AV_PIX_FMT_NV20BE,
++
++ AV_PIX_FMT_RGBA64BE,
++ AV_PIX_FMT_RGBA64LE,
++ AV_PIX_FMT_BGRA64BE,
++ AV_PIX_FMT_BGRA64LE,
++
++ AV_PIX_FMT_YVYU422,
++
++ AV_PIX_FMT_YA16BE,
++ AV_PIX_FMT_YA16LE,
++
++ AV_PIX_FMT_GBRAP,
++ AV_PIX_FMT_GBRAP16BE,
++ AV_PIX_FMT_GBRAP16LE,
++
++ AV_PIX_FMT_QSV,
++
++ AV_PIX_FMT_MMAL,
++
++ AV_PIX_FMT_D3D11VA_VLD,
++
++ AV_PIX_FMT_CUDA,
++
++ AV_PIX_FMT_0RGB,
++ AV_PIX_FMT_RGB0,
++ AV_PIX_FMT_0BGR,
++ AV_PIX_FMT_BGR0,
++
++ AV_PIX_FMT_YUV420P12BE,
++ AV_PIX_FMT_YUV420P12LE,
++ AV_PIX_FMT_YUV420P14BE,
++ AV_PIX_FMT_YUV420P14LE,
++ AV_PIX_FMT_YUV422P12BE,
++ AV_PIX_FMT_YUV422P12LE,
++ AV_PIX_FMT_YUV422P14BE,
++ AV_PIX_FMT_YUV422P14LE,
++ AV_PIX_FMT_YUV444P12BE,
++ AV_PIX_FMT_YUV444P12LE,
++ AV_PIX_FMT_YUV444P14BE,
++ AV_PIX_FMT_YUV444P14LE,
++ AV_PIX_FMT_GBRP12BE,
++ AV_PIX_FMT_GBRP12LE,
++ AV_PIX_FMT_GBRP14BE,
++ AV_PIX_FMT_GBRP14LE,
++ AV_PIX_FMT_YUVJ411P,
++
++ AV_PIX_FMT_BAYER_BGGR8,
++ AV_PIX_FMT_BAYER_RGGB8,
++ AV_PIX_FMT_BAYER_GBRG8,
++ AV_PIX_FMT_BAYER_GRBG8,
++ AV_PIX_FMT_BAYER_BGGR16LE,
++ AV_PIX_FMT_BAYER_BGGR16BE,
++ AV_PIX_FMT_BAYER_RGGB16LE,
++ AV_PIX_FMT_BAYER_RGGB16BE,
++ AV_PIX_FMT_BAYER_GBRG16LE,
++ AV_PIX_FMT_BAYER_GBRG16BE,
++ AV_PIX_FMT_BAYER_GRBG16LE,
++ AV_PIX_FMT_BAYER_GRBG16BE,
++
++ AV_PIX_FMT_XVMC,
++
++ AV_PIX_FMT_YUV440P10LE,
++ AV_PIX_FMT_YUV440P10BE,
++ AV_PIX_FMT_YUV440P12LE,
++ AV_PIX_FMT_YUV440P12BE,
++ AV_PIX_FMT_AYUV64LE,
++ AV_PIX_FMT_AYUV64BE,
++
++ AV_PIX_FMT_VIDEOTOOLBOX,
++
++ AV_PIX_FMT_P010LE,
++ AV_PIX_FMT_P010BE,
++
++ AV_PIX_FMT_GBRAP12BE,
++ AV_PIX_FMT_GBRAP12LE,
++
++ AV_PIX_FMT_GBRAP10BE,
++ AV_PIX_FMT_GBRAP10LE,
++
++ AV_PIX_FMT_MEDIACODEC,
++
++ AV_PIX_FMT_GRAY12BE,
++ AV_PIX_FMT_GRAY12LE,
++ AV_PIX_FMT_GRAY10BE,
++ AV_PIX_FMT_GRAY10LE,
++
++ AV_PIX_FMT_P016LE,
++ AV_PIX_FMT_P016BE,
++
++ AV_PIX_FMT_D3D11,
++
++ AV_PIX_FMT_GRAY9BE,
++ AV_PIX_FMT_GRAY9LE,
++
++ AV_PIX_FMT_GBRPF32BE,
++ AV_PIX_FMT_GBRPF32LE,
++ AV_PIX_FMT_GBRAPF32BE,
++ AV_PIX_FMT_GBRAPF32LE,
++
++ AV_PIX_FMT_DRM_PRIME,
++
++ AV_PIX_FMT_OPENCL,
++
++ AV_PIX_FMT_GRAY14BE,
++ AV_PIX_FMT_GRAY14LE,
++
++ AV_PIX_FMT_GRAYF32BE,
++ AV_PIX_FMT_GRAYF32LE,
++
++ AV_PIX_FMT_YUVA422P12BE,
++ AV_PIX_FMT_YUVA422P12LE,
++ AV_PIX_FMT_YUVA444P12BE,
++ AV_PIX_FMT_YUVA444P12LE,
++
++ AV_PIX_FMT_NV24,
++ AV_PIX_FMT_NV42,
++
++ AV_PIX_FMT_VULKAN,
++
++ AV_PIX_FMT_Y210BE,
++ AV_PIX_FMT_Y210LE,
++
++ AV_PIX_FMT_X2RGB10LE,
++ AV_PIX_FMT_X2RGB10BE,
++ AV_PIX_FMT_X2BGR10LE,
++ AV_PIX_FMT_X2BGR10BE,
++
++ AV_PIX_FMT_P210BE,
++ AV_PIX_FMT_P210LE,
++
++ AV_PIX_FMT_P410BE,
++ AV_PIX_FMT_P410LE,
++
++ AV_PIX_FMT_P216BE,
++ AV_PIX_FMT_P216LE,
++
++ AV_PIX_FMT_P416BE,
++ AV_PIX_FMT_P416LE,
++
++ AV_PIX_FMT_VUYA,
++
++ AV_PIX_FMT_RGBAF16BE,
++ AV_PIX_FMT_RGBAF16LE,
++
++ AV_PIX_FMT_VUYX,
++
++ AV_PIX_FMT_P012LE,
++ AV_PIX_FMT_P012BE,
++
++ AV_PIX_FMT_Y212BE,
++ AV_PIX_FMT_Y212LE,
++
++ AV_PIX_FMT_XV30BE,
++ AV_PIX_FMT_XV30LE,
++
++ AV_PIX_FMT_XV36BE,
++ AV_PIX_FMT_XV36LE,
++
++ AV_PIX_FMT_RGBF32BE,
++ AV_PIX_FMT_RGBF32LE,
++
++ AV_PIX_FMT_RGBAF32BE,
++ AV_PIX_FMT_RGBAF32LE,
++
++ AV_PIX_FMT_NB
++};
++
++# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##le
++
++#define AV_PIX_FMT_RGB32 AV_PIX_FMT_NE(ARGB, BGRA)
++#define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR)
++#define AV_PIX_FMT_BGR32 AV_PIX_FMT_NE(ABGR, RGBA)
++#define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB)
++#define AV_PIX_FMT_0RGB32 AV_PIX_FMT_NE(0RGB, BGR0)
++#define AV_PIX_FMT_0BGR32 AV_PIX_FMT_NE(0BGR, RGB0)
++
++#define AV_PIX_FMT_GRAY9 AV_PIX_FMT_NE(GRAY9BE, GRAY9LE)
++#define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE)
++#define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE)
++#define AV_PIX_FMT_GRAY14 AV_PIX_FMT_NE(GRAY14BE, GRAY14LE)
++#define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
++#define AV_PIX_FMT_YA16 AV_PIX_FMT_NE(YA16BE, YA16LE)
++#define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE)
++#define AV_PIX_FMT_RGB565 AV_PIX_FMT_NE(RGB565BE, RGB565LE)
++#define AV_PIX_FMT_RGB555 AV_PIX_FMT_NE(RGB555BE, RGB555LE)
++#define AV_PIX_FMT_RGB444 AV_PIX_FMT_NE(RGB444BE, RGB444LE)
++#define AV_PIX_FMT_RGBA64 AV_PIX_FMT_NE(RGBA64BE, RGBA64LE)
++#define AV_PIX_FMT_BGR48 AV_PIX_FMT_NE(BGR48BE, BGR48LE)
++#define AV_PIX_FMT_BGR565 AV_PIX_FMT_NE(BGR565BE, BGR565LE)
++#define AV_PIX_FMT_BGR555 AV_PIX_FMT_NE(BGR555BE, BGR555LE)
++#define AV_PIX_FMT_BGR444 AV_PIX_FMT_NE(BGR444BE, BGR444LE)
++#define AV_PIX_FMT_BGRA64 AV_PIX_FMT_NE(BGRA64BE, BGRA64LE)
++
++#define AV_PIX_FMT_YUV420P9 AV_PIX_FMT_NE(YUV420P9BE , YUV420P9LE)
++#define AV_PIX_FMT_YUV422P9 AV_PIX_FMT_NE(YUV422P9BE , YUV422P9LE)
++#define AV_PIX_FMT_YUV444P9 AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE)
++#define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE)
++#define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE)
++#define AV_PIX_FMT_YUV440P10 AV_PIX_FMT_NE(YUV440P10BE, YUV440P10LE)
++#define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE)
++#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE)
++#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE)
++#define AV_PIX_FMT_YUV440P12 AV_PIX_FMT_NE(YUV440P12BE, YUV440P12LE)
++#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE)
++#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE)
++#define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE)
++#define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE)
++#define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE)
++#define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE)
++#define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE)
++
++#define AV_PIX_FMT_GBRP9 AV_PIX_FMT_NE(GBRP9BE , GBRP9LE)
++#define AV_PIX_FMT_GBRP10 AV_PIX_FMT_NE(GBRP10BE, GBRP10LE)
++#define AV_PIX_FMT_GBRP12 AV_PIX_FMT_NE(GBRP12BE, GBRP12LE)
++#define AV_PIX_FMT_GBRP14 AV_PIX_FMT_NE(GBRP14BE, GBRP14LE)
++#define AV_PIX_FMT_GBRP16 AV_PIX_FMT_NE(GBRP16BE, GBRP16LE)
++#define AV_PIX_FMT_GBRAP10 AV_PIX_FMT_NE(GBRAP10BE, GBRAP10LE)
++#define AV_PIX_FMT_GBRAP12 AV_PIX_FMT_NE(GBRAP12BE, GBRAP12LE)
++#define AV_PIX_FMT_GBRAP16 AV_PIX_FMT_NE(GBRAP16BE, GBRAP16LE)
++
++#define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE, BAYER_BGGR16LE)
++#define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE, BAYER_RGGB16LE)
++#define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE, BAYER_GBRG16LE)
++#define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE, BAYER_GRBG16LE)
++
++#define AV_PIX_FMT_GBRPF32 AV_PIX_FMT_NE(GBRPF32BE, GBRPF32LE)
++#define AV_PIX_FMT_GBRAPF32 AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE)
++
++#define AV_PIX_FMT_GRAYF32 AV_PIX_FMT_NE(GRAYF32BE, GRAYF32LE)
++
++#define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
++#define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
++#define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
++#define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE)
++#define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE)
++#define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE)
++#define AV_PIX_FMT_YUVA422P12 AV_PIX_FMT_NE(YUVA422P12BE, YUVA422P12LE)
++#define AV_PIX_FMT_YUVA444P12 AV_PIX_FMT_NE(YUVA444P12BE, YUVA444P12LE)
++#define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE)
++#define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE)
++#define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE)
++
++#define AV_PIX_FMT_XYZ12 AV_PIX_FMT_NE(XYZ12BE, XYZ12LE)
++#define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE)
++#define AV_PIX_FMT_AYUV64 AV_PIX_FMT_NE(AYUV64BE, AYUV64LE)
++#define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE)
++#define AV_PIX_FMT_P012 AV_PIX_FMT_NE(P012BE, P012LE)
++#define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE)
++
++#define AV_PIX_FMT_Y210 AV_PIX_FMT_NE(Y210BE, Y210LE)
++#define AV_PIX_FMT_Y212 AV_PIX_FMT_NE(Y212BE, Y212LE)
++#define AV_PIX_FMT_XV30 AV_PIX_FMT_NE(XV30BE, XV30LE)
++#define AV_PIX_FMT_XV36 AV_PIX_FMT_NE(XV36BE, XV36LE)
++#define AV_PIX_FMT_X2RGB10 AV_PIX_FMT_NE(X2RGB10BE, X2RGB10LE)
++#define AV_PIX_FMT_X2BGR10 AV_PIX_FMT_NE(X2BGR10BE, X2BGR10LE)
++
++#define AV_PIX_FMT_P210 AV_PIX_FMT_NE(P210BE, P210LE)
++#define AV_PIX_FMT_P410 AV_PIX_FMT_NE(P410BE, P410LE)
++#define AV_PIX_FMT_P216 AV_PIX_FMT_NE(P216BE, P216LE)
++#define AV_PIX_FMT_P416 AV_PIX_FMT_NE(P416BE, P416LE)
++
++#define AV_PIX_FMT_RGBAF16 AV_PIX_FMT_NE(RGBAF16BE, RGBAF16LE)
++
++#define AV_PIX_FMT_RGBF32 AV_PIX_FMT_NE(RGBF32BE, RGBF32LE)
++#define AV_PIX_FMT_RGBAF32 AV_PIX_FMT_NE(RGBAF32BE, RGBAF32LE)
++
++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 = AVCOL_PRI_SMPTE428,
++ AVCOL_PRI_SMPTE431 = 11,
++ AVCOL_PRI_SMPTE432 = 12,
++ AVCOL_PRI_EBU3213 = 22,
++ AVCOL_PRI_JEDEC_P22 = AVCOL_PRI_EBU3213,
++ AVCOL_PRI_NB
++};
++
++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 = AVCOL_TRC_SMPTE2084,
++ AVCOL_TRC_SMPTE428 = 17,
++ AVCOL_TRC_SMPTEST428_1 = AVCOL_TRC_SMPTE428,
++ AVCOL_TRC_ARIB_STD_B67 = 18,
++ AVCOL_TRC_NB
++};
++
++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 = AVCOL_SPC_YCGCO,
++ 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_NB
++};
++
++enum AVColorRange {
++ AVCOL_RANGE_UNSPECIFIED = 0,
++
++ AVCOL_RANGE_MPEG = 1,
++
++ AVCOL_RANGE_JPEG = 2,
++ AVCOL_RANGE_NB
++};
++
++enum AVChromaLocation {
++ AVCHROMA_LOC_UNSPECIFIED = 0,
++ AVCHROMA_LOC_LEFT = 1,
++ AVCHROMA_LOC_CENTER = 2,
++ AVCHROMA_LOC_TOPLEFT = 3,
++ AVCHROMA_LOC_TOP = 4,
++ AVCHROMA_LOC_BOTTOMLEFT = 5,
++ AVCHROMA_LOC_BOTTOM = 6,
++ AVCHROMA_LOC_NB
++};
++
++static inline void *av_x_if_null(const void *p, const void *x)
++{
++ return (void *)(intptr_t)(p ? p : x);
++}
++
++unsigned av_int_list_length_for_size(unsigned elsize,
++ const void *list, uint64_t term) av_pure;
++
++#define av_int_list_length(list, term) \
++ av_int_list_length_for_size(sizeof(*(list)), list, term)
++
++attribute_deprecated
++FILE *av_fopen_utf8(const char *path, const char *mode);
++
++AVRational av_get_time_base_q(void);
++
++#define AV_FOURCC_MAX_STRING_SIZE 32
++
++#define av_fourcc2str(fourcc) av_fourcc_make_string((char[AV_FOURCC_MAX_STRING_SIZE]){0}, fourcc)
++
++char *av_fourcc_make_string(char *buf, uint32_t fourcc);
++
++#define AVUTIL_BUFFER_H
++
++typedef struct AVBuffer AVBuffer;
++
++typedef struct AVBufferRef {
++ AVBuffer *buffer;
++
++ uint8_t *data;
++
++ size_t size;
++} AVBufferRef;
++
++AVBufferRef *av_buffer_alloc(size_t size);
++
++AVBufferRef *av_buffer_allocz(size_t size);
++
++#define AV_BUFFER_FLAG_READONLY (1 << 0)
++
++AVBufferRef *av_buffer_create(uint8_t *data, size_t size,
++ void (*free)(void *opaque, uint8_t *data),
++ void *opaque, int flags);
++
++void av_buffer_default_free(void *opaque, uint8_t *data);
++
++AVBufferRef *av_buffer_ref(const AVBufferRef *buf);
++
++void av_buffer_unref(AVBufferRef **buf);
++
++int av_buffer_is_writable(const AVBufferRef *buf);
++
++void *av_buffer_get_opaque(const AVBufferRef *buf);
++
++int av_buffer_get_ref_count(const AVBufferRef *buf);
++
++int av_buffer_make_writable(AVBufferRef **buf);
++
++int av_buffer_realloc(AVBufferRef **buf, size_t size);
++
++int av_buffer_replace(AVBufferRef **dst, const AVBufferRef *src);
++
++typedef struct AVBufferPool AVBufferPool;
++
++AVBufferPool *av_buffer_pool_init(size_t size, AVBufferRef* (*alloc)(size_t size));
++
++AVBufferPool *av_buffer_pool_init2(size_t size, void *opaque,
++ AVBufferRef* (*alloc)(void *opaque, size_t size),
++ void (*pool_free)(void *opaque));
++
++void av_buffer_pool_uninit(AVBufferPool **pool);
++
++AVBufferRef *av_buffer_pool_get(AVBufferPool *pool);
++
++void *av_buffer_pool_buffer_get_opaque(const AVBufferRef *ref);
++
++#define AVUTIL_DICT_H
++
++#define AV_DICT_MATCH_CASE 1
++#define AV_DICT_IGNORE_SUFFIX 2
++
++#define AV_DICT_DONT_STRDUP_KEY 4
++
++#define AV_DICT_DONT_STRDUP_VAL 8
++
++#define AV_DICT_DONT_OVERWRITE 16
++#define AV_DICT_APPEND 32
++
++#define AV_DICT_MULTIKEY 64
++
++typedef struct AVDictionaryEntry {
++ char *key;
++ char *value;
++} AVDictionaryEntry;
++
++typedef struct AVDictionary AVDictionary;
++
++AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key,
++ const AVDictionaryEntry *prev, int flags);
++
++const AVDictionaryEntry *av_dict_iterate(const AVDictionary *m,
++ const AVDictionaryEntry *prev);
++
++int av_dict_count(const AVDictionary *m);
++
++int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags);
++
++int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags);
++
++int av_dict_parse_string(AVDictionary **pm, const char *str,
++ const char *key_val_sep, const char *pairs_sep,
++ int flags);
++
++int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags);
++
++void av_dict_free(AVDictionary **m);
++
++int av_dict_get_string(const AVDictionary *m, char **buffer,
++ const char key_val_sep, const char pairs_sep);
++
++#define AVUTIL_FRAME_H
++
++#define AVUTIL_CHANNEL_LAYOUT_H
++
++enum AVChannel {
++
++ AV_CHAN_NONE = -1,
++ AV_CHAN_FRONT_LEFT,
++ AV_CHAN_FRONT_RIGHT,
++ AV_CHAN_FRONT_CENTER,
++ AV_CHAN_LOW_FREQUENCY,
++ AV_CHAN_BACK_LEFT,
++ AV_CHAN_BACK_RIGHT,
++ AV_CHAN_FRONT_LEFT_OF_CENTER,
++ AV_CHAN_FRONT_RIGHT_OF_CENTER,
++ AV_CHAN_BACK_CENTER,
++ AV_CHAN_SIDE_LEFT,
++ AV_CHAN_SIDE_RIGHT,
++ AV_CHAN_TOP_CENTER,
++ AV_CHAN_TOP_FRONT_LEFT,
++ AV_CHAN_TOP_FRONT_CENTER,
++ AV_CHAN_TOP_FRONT_RIGHT,
++ AV_CHAN_TOP_BACK_LEFT,
++ AV_CHAN_TOP_BACK_CENTER,
++ AV_CHAN_TOP_BACK_RIGHT,
++
++ AV_CHAN_STEREO_LEFT = 29,
++
++ AV_CHAN_STEREO_RIGHT,
++ AV_CHAN_WIDE_LEFT,
++ AV_CHAN_WIDE_RIGHT,
++ AV_CHAN_SURROUND_DIRECT_LEFT,
++ AV_CHAN_SURROUND_DIRECT_RIGHT,
++ AV_CHAN_LOW_FREQUENCY_2,
++ AV_CHAN_TOP_SIDE_LEFT,
++ AV_CHAN_TOP_SIDE_RIGHT,
++ AV_CHAN_BOTTOM_FRONT_CENTER,
++ AV_CHAN_BOTTOM_FRONT_LEFT,
++ AV_CHAN_BOTTOM_FRONT_RIGHT,
++
++ AV_CHAN_UNUSED = 0x200,
++
++ AV_CHAN_UNKNOWN = 0x300,
++
++ AV_CHAN_AMBISONIC_BASE = 0x400,
++
++ AV_CHAN_AMBISONIC_END = 0x7ff,
++};
++
++enum AVChannelOrder {
++
++ AV_CHANNEL_ORDER_UNSPEC,
++
++ AV_CHANNEL_ORDER_NATIVE,
++
++ AV_CHANNEL_ORDER_CUSTOM,
++
++ AV_CHANNEL_ORDER_AMBISONIC,
++};
++
++#define AV_CH_FRONT_LEFT (1ULL << AV_CHAN_FRONT_LEFT )
++#define AV_CH_FRONT_RIGHT (1ULL << AV_CHAN_FRONT_RIGHT )
++#define AV_CH_FRONT_CENTER (1ULL << AV_CHAN_FRONT_CENTER )
++#define AV_CH_LOW_FREQUENCY (1ULL << AV_CHAN_LOW_FREQUENCY )
++#define AV_CH_BACK_LEFT (1ULL << AV_CHAN_BACK_LEFT )
++#define AV_CH_BACK_RIGHT (1ULL << AV_CHAN_BACK_RIGHT )
++#define AV_CH_FRONT_LEFT_OF_CENTER (1ULL << AV_CHAN_FRONT_LEFT_OF_CENTER )
++#define AV_CH_FRONT_RIGHT_OF_CENTER (1ULL << AV_CHAN_FRONT_RIGHT_OF_CENTER)
++#define AV_CH_BACK_CENTER (1ULL << AV_CHAN_BACK_CENTER )
++#define AV_CH_SIDE_LEFT (1ULL << AV_CHAN_SIDE_LEFT )
++#define AV_CH_SIDE_RIGHT (1ULL << AV_CHAN_SIDE_RIGHT )
++#define AV_CH_TOP_CENTER (1ULL << AV_CHAN_TOP_CENTER )
++#define AV_CH_TOP_FRONT_LEFT (1ULL << AV_CHAN_TOP_FRONT_LEFT )
++#define AV_CH_TOP_FRONT_CENTER (1ULL << AV_CHAN_TOP_FRONT_CENTER )
++#define AV_CH_TOP_FRONT_RIGHT (1ULL << AV_CHAN_TOP_FRONT_RIGHT )
++#define AV_CH_TOP_BACK_LEFT (1ULL << AV_CHAN_TOP_BACK_LEFT )
++#define AV_CH_TOP_BACK_CENTER (1ULL << AV_CHAN_TOP_BACK_CENTER )
++#define AV_CH_TOP_BACK_RIGHT (1ULL << AV_CHAN_TOP_BACK_RIGHT )
++#define AV_CH_STEREO_LEFT (1ULL << AV_CHAN_STEREO_LEFT )
++#define AV_CH_STEREO_RIGHT (1ULL << AV_CHAN_STEREO_RIGHT )
++#define AV_CH_WIDE_LEFT (1ULL << AV_CHAN_WIDE_LEFT )
++#define AV_CH_WIDE_RIGHT (1ULL << AV_CHAN_WIDE_RIGHT )
++#define AV_CH_SURROUND_DIRECT_LEFT (1ULL << AV_CHAN_SURROUND_DIRECT_LEFT )
++#define AV_CH_SURROUND_DIRECT_RIGHT (1ULL << AV_CHAN_SURROUND_DIRECT_RIGHT)
++#define AV_CH_LOW_FREQUENCY_2 (1ULL << AV_CHAN_LOW_FREQUENCY_2 )
++#define AV_CH_TOP_SIDE_LEFT (1ULL << AV_CHAN_TOP_SIDE_LEFT )
++#define AV_CH_TOP_SIDE_RIGHT (1ULL << AV_CHAN_TOP_SIDE_RIGHT )
++#define AV_CH_BOTTOM_FRONT_CENTER (1ULL << AV_CHAN_BOTTOM_FRONT_CENTER )
++#define AV_CH_BOTTOM_FRONT_LEFT (1ULL << AV_CHAN_BOTTOM_FRONT_LEFT )
++#define AV_CH_BOTTOM_FRONT_RIGHT (1ULL << AV_CHAN_BOTTOM_FRONT_RIGHT )
++
++#define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL
++
++#define AV_CH_LAYOUT_MONO (AV_CH_FRONT_CENTER)
++#define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
++#define AV_CH_LAYOUT_2POINT1 (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY)
++#define AV_CH_LAYOUT_2_1 (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER)
++#define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)
++#define AV_CH_LAYOUT_3POINT1 (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY)
++#define AV_CH_LAYOUT_4POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER)
++#define AV_CH_LAYOUT_4POINT1 (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY)
++#define AV_CH_LAYOUT_2_2 (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
++#define AV_CH_LAYOUT_QUAD (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
++#define AV_CH_LAYOUT_5POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
++#define AV_CH_LAYOUT_5POINT1 (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY)
++#define AV_CH_LAYOUT_5POINT0_BACK (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
++#define AV_CH_LAYOUT_5POINT1_BACK (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY)
++#define AV_CH_LAYOUT_6POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER)
++#define AV_CH_LAYOUT_6POINT0_FRONT (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
++#define AV_CH_LAYOUT_HEXAGONAL (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER)
++#define AV_CH_LAYOUT_6POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER)
++#define AV_CH_LAYOUT_6POINT1_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER)
++#define AV_CH_LAYOUT_6POINT1_FRONT (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY)
++#define AV_CH_LAYOUT_7POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
++#define AV_CH_LAYOUT_7POINT0_FRONT (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
++#define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
++#define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
++#define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
++#define AV_CH_LAYOUT_7POINT1_TOP_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT)
++#define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
++#define 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)
++#define 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)
++#define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
++#define AV_CH_LAYOUT_22POINT2 (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_LOW_FREQUENCY_2|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_CENTER|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_SIDE_LEFT|AV_CH_TOP_SIDE_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_BOTTOM_FRONT_CENTER|AV_CH_BOTTOM_FRONT_LEFT|AV_CH_BOTTOM_FRONT_RIGHT)
++
++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
++};
++
++typedef struct AVChannelCustom {
++ enum AVChannel id;
++ char name[16];
++ void *opaque;
++} AVChannelCustom;
++
++typedef struct AVChannelLayout {
++
++ enum AVChannelOrder order;
++
++ int nb_channels;
++
++ union {
++
++ uint64_t mask;
++
++ AVChannelCustom *map;
++ } u;
++
++ void *opaque;
++} AVChannelLayout;
++
++#define AV_CHANNEL_LAYOUT_MASK(nb, m) \
++ { .order = AV_CHANNEL_ORDER_NATIVE, .nb_channels = (nb), .u = { .mask = (m) }}
++
++#define AV_CHANNEL_LAYOUT_MONO AV_CHANNEL_LAYOUT_MASK(1, AV_CH_LAYOUT_MONO)
++#define AV_CHANNEL_LAYOUT_STEREO AV_CHANNEL_LAYOUT_MASK(2, AV_CH_LAYOUT_STEREO)
++#define AV_CHANNEL_LAYOUT_2POINT1 AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_2POINT1)
++#define AV_CHANNEL_LAYOUT_2_1 AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_2_1)
++#define AV_CHANNEL_LAYOUT_SURROUND AV_CHANNEL_LAYOUT_MASK(3, AV_CH_LAYOUT_SURROUND)
++#define AV_CHANNEL_LAYOUT_3POINT1 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_3POINT1)
++#define AV_CHANNEL_LAYOUT_4POINT0 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_4POINT0)
++#define AV_CHANNEL_LAYOUT_4POINT1 AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_4POINT1)
++#define AV_CHANNEL_LAYOUT_2_2 AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_2_2)
++#define AV_CHANNEL_LAYOUT_QUAD AV_CHANNEL_LAYOUT_MASK(4, AV_CH_LAYOUT_QUAD)
++#define AV_CHANNEL_LAYOUT_5POINT0 AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_5POINT0)
++#define AV_CHANNEL_LAYOUT_5POINT1 AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_5POINT1)
++#define AV_CHANNEL_LAYOUT_5POINT0_BACK AV_CHANNEL_LAYOUT_MASK(5, AV_CH_LAYOUT_5POINT0_BACK)
++#define AV_CHANNEL_LAYOUT_5POINT1_BACK AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_5POINT1_BACK)
++#define AV_CHANNEL_LAYOUT_6POINT0 AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_6POINT0)
++#define AV_CHANNEL_LAYOUT_6POINT0_FRONT AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_6POINT0_FRONT)
++#define AV_CHANNEL_LAYOUT_HEXAGONAL AV_CHANNEL_LAYOUT_MASK(6, AV_CH_LAYOUT_HEXAGONAL)
++#define AV_CHANNEL_LAYOUT_6POINT1 AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1)
++#define AV_CHANNEL_LAYOUT_6POINT1_BACK AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1_BACK)
++#define AV_CHANNEL_LAYOUT_6POINT1_FRONT AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_6POINT1_FRONT)
++#define AV_CHANNEL_LAYOUT_7POINT0 AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_7POINT0)
++#define AV_CHANNEL_LAYOUT_7POINT0_FRONT AV_CHANNEL_LAYOUT_MASK(7, AV_CH_LAYOUT_7POINT0_FRONT)
++#define AV_CHANNEL_LAYOUT_7POINT1 AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1)
++#define AV_CHANNEL_LAYOUT_7POINT1_WIDE AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_WIDE)
++#define AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_WIDE_BACK)
++#define AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_7POINT1_TOP_BACK)
++#define AV_CHANNEL_LAYOUT_OCTAGONAL AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_OCTAGONAL)
++#define AV_CHANNEL_LAYOUT_CUBE AV_CHANNEL_LAYOUT_MASK(8, AV_CH_LAYOUT_CUBE)
++#define AV_CHANNEL_LAYOUT_HEXADECAGONAL AV_CHANNEL_LAYOUT_MASK(16, AV_CH_LAYOUT_HEXADECAGONAL)
++#define AV_CHANNEL_LAYOUT_STEREO_DOWNMIX AV_CHANNEL_LAYOUT_MASK(2, AV_CH_LAYOUT_STEREO_DOWNMIX)
++#define AV_CHANNEL_LAYOUT_22POINT2 AV_CHANNEL_LAYOUT_MASK(24, AV_CH_LAYOUT_22POINT2)
++#define AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER \
++ { .order = AV_CHANNEL_ORDER_AMBISONIC, .nb_channels = 4, .u = { .mask = 0 }}
++
++struct AVBPrint;
++
++attribute_deprecated
++uint64_t av_get_channel_layout(const char *name);
++
++attribute_deprecated
++int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels);
++
++attribute_deprecated
++void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
++
++attribute_deprecated
++void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout);
++
++attribute_deprecated
++int av_get_channel_layout_nb_channels(uint64_t channel_layout);
++
++attribute_deprecated
++int64_t av_get_default_channel_layout(int nb_channels);
++
++attribute_deprecated
++int av_get_channel_layout_channel_index(uint64_t channel_layout,
++ uint64_t channel);
++
++attribute_deprecated
++uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index);
++
++attribute_deprecated
++const char *av_get_channel_name(uint64_t channel);
++
++attribute_deprecated
++const char *av_get_channel_description(uint64_t channel);
++
++attribute_deprecated
++int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
++ const char **name);
++
++int av_channel_name(char *buf, size_t buf_size, enum AVChannel channel);
++
++void av_channel_name_bprint(struct AVBPrint *bp, enum AVChannel channel_id);
++
++int av_channel_description(char *buf, size_t buf_size, enum AVChannel channel);
++
++void av_channel_description_bprint(struct AVBPrint *bp, enum AVChannel channel_id);
++
++enum AVChannel av_channel_from_string(const char *name);
++
++int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask);
++
++int av_channel_layout_from_string(AVChannelLayout *channel_layout,
++ const char *str);
++
++void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels);
++
++const AVChannelLayout *av_channel_layout_standard(void **opaque);
++
++void av_channel_layout_uninit(AVChannelLayout *channel_layout);
++
++int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src);
++
++int av_channel_layout_describe(const AVChannelLayout *channel_layout,
++ char *buf, size_t buf_size);
++
++int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout,
++ struct AVBPrint *bp);
++
++enum AVChannel
++av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx);
++
++int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout,
++ enum AVChannel channel);
++
++int av_channel_layout_index_from_string(const AVChannelLayout *channel_layout,
++ const char *name);
++
++enum AVChannel
++av_channel_layout_channel_from_string(const AVChannelLayout *channel_layout,
++ const char *name);
++
++uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout,
++ uint64_t mask);
++
++int av_channel_layout_check(const AVChannelLayout *channel_layout);
++
++int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1);
++
++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,
++};
++
++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,
++};
++
++typedef struct AVFrameSideData {
++ enum AVFrameSideDataType type;
++ uint8_t *data;
++ size_t size;
++ AVDictionary *metadata;
++ AVBufferRef *buf;
++} AVFrameSideData;
++
++typedef struct AVRegionOfInterest {
++
++ uint32_t self_size;
++
++ int top;
++ int bottom;
++ int left;
++ int right;
++
++ AVRational qoffset;
++} AVRegionOfInterest;
++
++typedef struct AVFrame {
++#define AV_NUM_DATA_POINTERS 8
++
++ uint8_t *data[AV_NUM_DATA_POINTERS];
++
++ int linesize[AV_NUM_DATA_POINTERS];
++
++ uint8_t **extended_data;
++
++ int width, height;
++
++ int nb_samples;
++
++ int format;
++
++ int key_frame;
++
++ enum AVPictureType pict_type;
++
++ AVRational sample_aspect_ratio;
++
++ int64_t pts;
++
++ int64_t pkt_dts;
++
++ AVRational time_base;
++
++ attribute_deprecated
++ int coded_picture_number;
++
++ attribute_deprecated
++ int display_picture_number;
++
++ int quality;
++
++ void *opaque;
++
++ int repeat_pict;
++
++ int interlaced_frame;
++
++ int top_field_first;
++
++ int palette_has_changed;
++
++ attribute_deprecated
++ int64_t reordered_opaque;
++
++ int sample_rate;
++
++ attribute_deprecated
++ uint64_t channel_layout;
++
++ AVBufferRef *buf[AV_NUM_DATA_POINTERS];
++
++ AVBufferRef **extended_buf;
++
++ int nb_extended_buf;
++
++ AVFrameSideData **side_data;
++ int nb_side_data;
++
++#define AV_FRAME_FLAG_CORRUPT (1 << 0)
++
++#define AV_FRAME_FLAG_DISCARD (1 << 2)
++
++ int flags;
++
++ enum AVColorRange color_range;
++
++ enum AVColorPrimaries color_primaries;
++
++ enum AVColorTransferCharacteristic color_trc;
++
++ enum AVColorSpace colorspace;
++
++ enum AVChromaLocation chroma_location;
++
++ int64_t best_effort_timestamp;
++
++ int64_t pkt_pos;
++
++ attribute_deprecated
++ int64_t pkt_duration;
++
++ AVDictionary *metadata;
++
++ int decode_error_flags;
++#define FF_DECODE_ERROR_INVALID_BITSTREAM 1
++#define FF_DECODE_ERROR_MISSING_REFERENCE 2
++#define FF_DECODE_ERROR_CONCEALMENT_ACTIVE 4
++#define FF_DECODE_ERROR_DECODE_SLICES 8
++
++ attribute_deprecated
++ int channels;
++
++ int pkt_size;
++
++ AVBufferRef *hw_frames_ctx;
++
++ AVBufferRef *opaque_ref;
++
++ size_t crop_top;
++ size_t crop_bottom;
++ size_t crop_left;
++ size_t crop_right;
++
++ AVBufferRef *private_ref;
++
++ AVChannelLayout ch_layout;
++
++ int64_t duration;
++} AVFrame;
++
++AVFrame *av_frame_alloc(void);
++
++void av_frame_free(AVFrame **frame);
++
++int av_frame_ref(AVFrame *dst, const AVFrame *src);
++
++AVFrame *av_frame_clone(const AVFrame *src);
++
++void av_frame_unref(AVFrame *frame);
++
++void av_frame_move_ref(AVFrame *dst, AVFrame *src);
++
++int av_frame_get_buffer(AVFrame *frame, int align);
++
++int av_frame_is_writable(AVFrame *frame);
++
++int av_frame_make_writable(AVFrame *frame);
++
++int av_frame_copy(AVFrame *dst, const AVFrame *src);
++
++int av_frame_copy_props(AVFrame *dst, const AVFrame *src);
++
++AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane);
++
++AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
++ enum AVFrameSideDataType type,
++ size_t size);
++
++AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame,
++ enum AVFrameSideDataType type,
++ AVBufferRef *buf);
++
++AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
++ enum AVFrameSideDataType type);
++
++void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);
++
++enum {
++
++ AV_FRAME_CROP_UNALIGNED = 1 << 0,
++};
++
++int av_frame_apply_cropping(AVFrame *frame, int flags);
++
++const char *av_frame_side_data_name(enum AVFrameSideDataType type);
++
++#define AVCODEC_CODEC_H
++
++#define AVUTIL_HWCONTEXT_H
++
++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,
++};
++
++typedef struct AVHWDeviceInternal AVHWDeviceInternal;
++
++typedef struct AVHWDeviceContext {
++
++ const AVClass *av_class;
++
++ AVHWDeviceInternal *internal;
++
++ enum AVHWDeviceType type;
++
++ void *hwctx;
++
++ void (*free)(struct AVHWDeviceContext *ctx);
++
++ void *user_opaque;
++} AVHWDeviceContext;
++
++typedef struct AVHWFramesInternal AVHWFramesInternal;
++
++typedef struct AVHWFramesContext {
++
++ const AVClass *av_class;
++
++ AVHWFramesInternal *internal;
++
++ AVBufferRef *device_ref;
++
++ AVHWDeviceContext *device_ctx;
++
++ void *hwctx;
++
++ void (*free)(struct AVHWFramesContext *ctx);
++
++ void *user_opaque;
++
++ AVBufferPool *pool;
++
++ int initial_pool_size;
++
++ enum AVPixelFormat format;
++
++ enum AVPixelFormat sw_format;
++
++ int width, height;
++} AVHWFramesContext;
++
++enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name);
++
++const char *av_hwdevice_get_type_name(enum AVHWDeviceType type);
++
++enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev);
++
++AVBufferRef *av_hwdevice_ctx_alloc(enum AVHWDeviceType type);
++
++int av_hwdevice_ctx_init(AVBufferRef *ref);
++
++int av_hwdevice_ctx_create(AVBufferRef **device_ctx, enum AVHWDeviceType type,
++ const char *device, AVDictionary *opts, int flags);
++
++int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ctx,
++ enum AVHWDeviceType type,
++ AVBufferRef *src_ctx, int flags);
++
++int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ctx,
++ enum AVHWDeviceType type,
++ AVBufferRef *src_ctx,
++ AVDictionary *options, int flags);
++
++AVBufferRef *av_hwframe_ctx_alloc(AVBufferRef *device_ctx);
++
++int av_hwframe_ctx_init(AVBufferRef *ref);
++
++int av_hwframe_get_buffer(AVBufferRef *hwframe_ctx, AVFrame *frame, int flags);
++
++int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags);
++
++enum AVHWFrameTransferDirection {
++
++ AV_HWFRAME_TRANSFER_DIRECTION_FROM,
++
++ AV_HWFRAME_TRANSFER_DIRECTION_TO,
++};
++
++int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ctx,
++ enum AVHWFrameTransferDirection dir,
++ enum AVPixelFormat **formats, int flags);
++
++typedef struct AVHWFramesConstraints {
++
++ enum AVPixelFormat *valid_hw_formats;
++
++ enum AVPixelFormat *valid_sw_formats;
++
++ int min_width;
++ int min_height;
++
++ int max_width;
++ int max_height;
++} AVHWFramesConstraints;
++
++void *av_hwdevice_hwconfig_alloc(AVBufferRef *device_ctx);
++
++AVHWFramesConstraints *av_hwdevice_get_hwframe_constraints(AVBufferRef *ref,
++ const void *hwconfig);
++
++void av_hwframe_constraints_free(AVHWFramesConstraints **constraints);
++
++enum {
++
++ AV_HWFRAME_MAP_READ = 1 << 0,
++
++ AV_HWFRAME_MAP_WRITE = 1 << 1,
++
++ AV_HWFRAME_MAP_OVERWRITE = 1 << 2,
++
++ AV_HWFRAME_MAP_DIRECT = 1 << 3,
++};
++
++int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags);
++
++int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx,
++ enum AVPixelFormat format,
++ AVBufferRef *derived_device_ctx,
++ AVBufferRef *source_frame_ctx,
++ int flags);
++
++#define AVCODEC_CODEC_ID_H
++
++#define AVCODEC_VERSION_MAJOR_H
++
++#define LIBAVCODEC_VERSION_MAJOR 60
++
++#define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 61)
++#define FF_API_IDCT_NONE (LIBAVCODEC_VERSION_MAJOR < 61)
++#define FF_API_SVTAV1_OPTS (LIBAVCODEC_VERSION_MAJOR < 61)
++#define FF_API_AYUV_CODECID (LIBAVCODEC_VERSION_MAJOR < 61)
++#define FF_API_VT_OUTPUT_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 61)
++#define FF_API_AVCODEC_CHROMA_POS (LIBAVCODEC_VERSION_MAJOR < 61)
++#define FF_API_VT_HWACCEL_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 61)
++#define FF_API_AVCTX_FRAME_NUMBER (LIBAVCODEC_VERSION_MAJOR < 61)
++
++#define FF_CODEC_CRYSTAL_HD (LIBAVCODEC_VERSION_MAJOR < 61)
++
++enum AVCodecID {
++ AV_CODEC_ID_NONE,
++
++ AV_CODEC_ID_MPEG1VIDEO,
++ AV_CODEC_ID_MPEG2VIDEO,
++ AV_CODEC_ID_H261,
++ AV_CODEC_ID_H263,
++ AV_CODEC_ID_RV10,
++ AV_CODEC_ID_RV20,
++ AV_CODEC_ID_MJPEG,
++ AV_CODEC_ID_MJPEGB,
++ AV_CODEC_ID_LJPEG,
++ AV_CODEC_ID_SP5X,
++ AV_CODEC_ID_JPEGLS,
++ AV_CODEC_ID_MPEG4,
++ AV_CODEC_ID_RAWVIDEO,
++ AV_CODEC_ID_MSMPEG4V1,
++ AV_CODEC_ID_MSMPEG4V2,
++ AV_CODEC_ID_MSMPEG4V3,
++ AV_CODEC_ID_WMV1,
++ AV_CODEC_ID_WMV2,
++ AV_CODEC_ID_H263P,
++ AV_CODEC_ID_H263I,
++ AV_CODEC_ID_FLV1,
++ AV_CODEC_ID_SVQ1,
++ AV_CODEC_ID_SVQ3,
++ AV_CODEC_ID_DVVIDEO,
++ AV_CODEC_ID_HUFFYUV,
++ AV_CODEC_ID_CYUV,
++ AV_CODEC_ID_H264,
++ AV_CODEC_ID_INDEO3,
++ AV_CODEC_ID_VP3,
++ AV_CODEC_ID_THEORA,
++ AV_CODEC_ID_ASV1,
++ AV_CODEC_ID_ASV2,
++ AV_CODEC_ID_FFV1,
++ AV_CODEC_ID_4XM,
++ AV_CODEC_ID_VCR1,
++ AV_CODEC_ID_CLJR,
++ AV_CODEC_ID_MDEC,
++ AV_CODEC_ID_ROQ,
++ AV_CODEC_ID_INTERPLAY_VIDEO,
++ AV_CODEC_ID_XAN_WC3,
++ AV_CODEC_ID_XAN_WC4,
++ AV_CODEC_ID_RPZA,
++ AV_CODEC_ID_CINEPAK,
++ AV_CODEC_ID_WS_VQA,
++ AV_CODEC_ID_MSRLE,
++ AV_CODEC_ID_MSVIDEO1,
++ AV_CODEC_ID_IDCIN,
++ AV_CODEC_ID_8BPS,
++ AV_CODEC_ID_SMC,
++ AV_CODEC_ID_FLIC,
++ AV_CODEC_ID_TRUEMOTION1,
++ AV_CODEC_ID_VMDVIDEO,
++ AV_CODEC_ID_MSZH,
++ AV_CODEC_ID_ZLIB,
++ AV_CODEC_ID_QTRLE,
++ AV_CODEC_ID_TSCC,
++ AV_CODEC_ID_ULTI,
++ AV_CODEC_ID_QDRAW,
++ AV_CODEC_ID_VIXL,
++ AV_CODEC_ID_QPEG,
++ AV_CODEC_ID_PNG,
++ AV_CODEC_ID_PPM,
++ AV_CODEC_ID_PBM,
++ AV_CODEC_ID_PGM,
++ AV_CODEC_ID_PGMYUV,
++ AV_CODEC_ID_PAM,
++ AV_CODEC_ID_FFVHUFF,
++ AV_CODEC_ID_RV30,
++ AV_CODEC_ID_RV40,
++ AV_CODEC_ID_VC1,
++ AV_CODEC_ID_WMV3,
++ AV_CODEC_ID_LOCO,
++ AV_CODEC_ID_WNV1,
++ AV_CODEC_ID_AASC,
++ AV_CODEC_ID_INDEO2,
++ AV_CODEC_ID_FRAPS,
++ AV_CODEC_ID_TRUEMOTION2,
++ AV_CODEC_ID_BMP,
++ AV_CODEC_ID_CSCD,
++ AV_CODEC_ID_MMVIDEO,
++ AV_CODEC_ID_ZMBV,
++ AV_CODEC_ID_AVS,
++ AV_CODEC_ID_SMACKVIDEO,
++ AV_CODEC_ID_NUV,
++ AV_CODEC_ID_KMVC,
++ AV_CODEC_ID_FLASHSV,
++ AV_CODEC_ID_CAVS,
++ AV_CODEC_ID_JPEG2000,
++ AV_CODEC_ID_VMNC,
++ AV_CODEC_ID_VP5,
++ AV_CODEC_ID_VP6,
++ AV_CODEC_ID_VP6F,
++ AV_CODEC_ID_TARGA,
++ AV_CODEC_ID_DSICINVIDEO,
++ AV_CODEC_ID_TIERTEXSEQVIDEO,
++ AV_CODEC_ID_TIFF,
++ AV_CODEC_ID_GIF,
++ AV_CODEC_ID_DXA,
++ AV_CODEC_ID_DNXHD,
++ AV_CODEC_ID_THP,
++ AV_CODEC_ID_SGI,
++ AV_CODEC_ID_C93,
++ AV_CODEC_ID_BETHSOFTVID,
++ AV_CODEC_ID_PTX,
++ AV_CODEC_ID_TXD,
++ AV_CODEC_ID_VP6A,
++ AV_CODEC_ID_AMV,
++ AV_CODEC_ID_VB,
++ AV_CODEC_ID_PCX,
++ AV_CODEC_ID_SUNRAST,
++ AV_CODEC_ID_INDEO4,
++ AV_CODEC_ID_INDEO5,
++ AV_CODEC_ID_MIMIC,
++ AV_CODEC_ID_RL2,
++ AV_CODEC_ID_ESCAPE124,
++ AV_CODEC_ID_DIRAC,
++ AV_CODEC_ID_BFI,
++ AV_CODEC_ID_CMV,
++ AV_CODEC_ID_MOTIONPIXELS,
++ AV_CODEC_ID_TGV,
++ AV_CODEC_ID_TGQ,
++ AV_CODEC_ID_TQI,
++ AV_CODEC_ID_AURA,
++ AV_CODEC_ID_AURA2,
++ AV_CODEC_ID_V210X,
++ AV_CODEC_ID_TMV,
++ AV_CODEC_ID_V210,
++ AV_CODEC_ID_DPX,
++ AV_CODEC_ID_MAD,
++ AV_CODEC_ID_FRWU,
++ AV_CODEC_ID_FLASHSV2,
++ AV_CODEC_ID_CDGRAPHICS,
++ AV_CODEC_ID_R210,
++ AV_CODEC_ID_ANM,
++ AV_CODEC_ID_BINKVIDEO,
++ AV_CODEC_ID_IFF_ILBM,
++#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
++ AV_CODEC_ID_KGV1,
++ AV_CODEC_ID_YOP,
++ AV_CODEC_ID_VP8,
++ AV_CODEC_ID_PICTOR,
++ AV_CODEC_ID_ANSI,
++ AV_CODEC_ID_A64_MULTI,
++ AV_CODEC_ID_A64_MULTI5,
++ AV_CODEC_ID_R10K,
++ AV_CODEC_ID_MXPEG,
++ AV_CODEC_ID_LAGARITH,
++ AV_CODEC_ID_PRORES,
++ AV_CODEC_ID_JV,
++ AV_CODEC_ID_DFA,
++ AV_CODEC_ID_WMV3IMAGE,
++ AV_CODEC_ID_VC1IMAGE,
++ AV_CODEC_ID_UTVIDEO,
++ AV_CODEC_ID_BMV_VIDEO,
++ AV_CODEC_ID_VBLE,
++ AV_CODEC_ID_DXTORY,
++ AV_CODEC_ID_V410,
++ AV_CODEC_ID_XWD,
++ AV_CODEC_ID_CDXL,
++ AV_CODEC_ID_XBM,
++ AV_CODEC_ID_ZEROCODEC,
++ AV_CODEC_ID_MSS1,
++ AV_CODEC_ID_MSA1,
++ AV_CODEC_ID_TSCC2,
++ AV_CODEC_ID_MTS2,
++ AV_CODEC_ID_CLLC,
++ AV_CODEC_ID_MSS2,
++ AV_CODEC_ID_VP9,
++ AV_CODEC_ID_AIC,
++ AV_CODEC_ID_ESCAPE130,
++ AV_CODEC_ID_G2M,
++ AV_CODEC_ID_WEBP,
++ AV_CODEC_ID_HNM4_VIDEO,
++ AV_CODEC_ID_HEVC,
++#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
++ AV_CODEC_ID_FIC,
++ AV_CODEC_ID_ALIAS_PIX,
++ AV_CODEC_ID_BRENDER_PIX,
++ AV_CODEC_ID_PAF_VIDEO,
++ AV_CODEC_ID_EXR,
++ AV_CODEC_ID_VP7,
++ AV_CODEC_ID_SANM,
++ AV_CODEC_ID_SGIRLE,
++ AV_CODEC_ID_MVC1,
++ AV_CODEC_ID_MVC2,
++ AV_CODEC_ID_HQX,
++ AV_CODEC_ID_TDSC,
++ AV_CODEC_ID_HQ_HQA,
++ AV_CODEC_ID_HAP,
++ AV_CODEC_ID_DDS,
++ AV_CODEC_ID_DXV,
++ AV_CODEC_ID_SCREENPRESSO,
++ AV_CODEC_ID_RSCC,
++ AV_CODEC_ID_AVS2,
++ AV_CODEC_ID_PGX,
++ AV_CODEC_ID_AVS3,
++ AV_CODEC_ID_MSP2,
++ AV_CODEC_ID_VVC,
++#define AV_CODEC_ID_H266 AV_CODEC_ID_VVC
++ AV_CODEC_ID_Y41P,
++ AV_CODEC_ID_AVRP,
++ AV_CODEC_ID_012V,
++ AV_CODEC_ID_AVUI,
++ AV_CODEC_ID_AYUV,
++ AV_CODEC_ID_TARGA_Y216,
++ AV_CODEC_ID_V308,
++ AV_CODEC_ID_V408,
++ AV_CODEC_ID_YUV4,
++ AV_CODEC_ID_AVRN,
++ AV_CODEC_ID_CPIA,
++ AV_CODEC_ID_XFACE,
++ AV_CODEC_ID_SNOW,
++ AV_CODEC_ID_SMVJPEG,
++ AV_CODEC_ID_APNG,
++ AV_CODEC_ID_DAALA,
++ AV_CODEC_ID_CFHD,
++ AV_CODEC_ID_TRUEMOTION2RT,
++ AV_CODEC_ID_M101,
++ AV_CODEC_ID_MAGICYUV,
++ AV_CODEC_ID_SHEERVIDEO,
++ AV_CODEC_ID_YLC,
++ AV_CODEC_ID_PSD,
++ AV_CODEC_ID_PIXLET,
++ AV_CODEC_ID_SPEEDHQ,
++ AV_CODEC_ID_FMVC,
++ AV_CODEC_ID_SCPR,
++ AV_CODEC_ID_CLEARVIDEO,
++ AV_CODEC_ID_XPM,
++ AV_CODEC_ID_AV1,
++ AV_CODEC_ID_BITPACKED,
++ AV_CODEC_ID_MSCC,
++ AV_CODEC_ID_SRGC,
++ AV_CODEC_ID_SVG,
++ AV_CODEC_ID_GDV,
++ AV_CODEC_ID_FITS,
++ AV_CODEC_ID_IMM4,
++ AV_CODEC_ID_PROSUMER,
++ AV_CODEC_ID_MWSC,
++ AV_CODEC_ID_WCMV,
++ AV_CODEC_ID_RASC,
++ AV_CODEC_ID_HYMT,
++ AV_CODEC_ID_ARBC,
++ AV_CODEC_ID_AGM,
++ AV_CODEC_ID_LSCR,
++ AV_CODEC_ID_VP4,
++ AV_CODEC_ID_IMM5,
++ AV_CODEC_ID_MVDV,
++ AV_CODEC_ID_MVHA,
++ AV_CODEC_ID_CDTOONS,
++ AV_CODEC_ID_MV30,
++ AV_CODEC_ID_NOTCHLC,
++ AV_CODEC_ID_PFM,
++ AV_CODEC_ID_MOBICLIP,
++ AV_CODEC_ID_PHOTOCD,
++ AV_CODEC_ID_IPU,
++ AV_CODEC_ID_ARGO,
++ AV_CODEC_ID_CRI,
++ AV_CODEC_ID_SIMBIOSIS_IMX,
++ AV_CODEC_ID_SGA_VIDEO,
++ AV_CODEC_ID_GEM,
++ AV_CODEC_ID_VBN,
++ AV_CODEC_ID_JPEGXL,
++ AV_CODEC_ID_QOI,
++ AV_CODEC_ID_PHM,
++ AV_CODEC_ID_RADIANCE_HDR,
++ AV_CODEC_ID_WBMP,
++ AV_CODEC_ID_MEDIA100,
++ AV_CODEC_ID_VQC,
++
++ AV_CODEC_ID_FIRST_AUDIO = 0x10000,
++ AV_CODEC_ID_PCM_S16LE = 0x10000,
++ AV_CODEC_ID_PCM_S16BE,
++ AV_CODEC_ID_PCM_U16LE,
++ AV_CODEC_ID_PCM_U16BE,
++ AV_CODEC_ID_PCM_S8,
++ AV_CODEC_ID_PCM_U8,
++ AV_CODEC_ID_PCM_MULAW,
++ AV_CODEC_ID_PCM_ALAW,
++ AV_CODEC_ID_PCM_S32LE,
++ AV_CODEC_ID_PCM_S32BE,
++ AV_CODEC_ID_PCM_U32LE,
++ AV_CODEC_ID_PCM_U32BE,
++ AV_CODEC_ID_PCM_S24LE,
++ AV_CODEC_ID_PCM_S24BE,
++ AV_CODEC_ID_PCM_U24LE,
++ AV_CODEC_ID_PCM_U24BE,
++ AV_CODEC_ID_PCM_S24DAUD,
++ AV_CODEC_ID_PCM_ZORK,
++ AV_CODEC_ID_PCM_S16LE_PLANAR,
++ AV_CODEC_ID_PCM_DVD,
++ AV_CODEC_ID_PCM_F32BE,
++ AV_CODEC_ID_PCM_F32LE,
++ AV_CODEC_ID_PCM_F64BE,
++ AV_CODEC_ID_PCM_F64LE,
++ AV_CODEC_ID_PCM_BLURAY,
++ AV_CODEC_ID_PCM_LXF,
++ AV_CODEC_ID_S302M,
++ AV_CODEC_ID_PCM_S8_PLANAR,
++ AV_CODEC_ID_PCM_S24LE_PLANAR,
++ AV_CODEC_ID_PCM_S32LE_PLANAR,
++ AV_CODEC_ID_PCM_S16BE_PLANAR,
++ AV_CODEC_ID_PCM_S64LE,
++ AV_CODEC_ID_PCM_S64BE,
++ AV_CODEC_ID_PCM_F16LE,
++ AV_CODEC_ID_PCM_F24LE,
++ AV_CODEC_ID_PCM_VIDC,
++ AV_CODEC_ID_PCM_SGA,
++
++ AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
++ AV_CODEC_ID_ADPCM_IMA_WAV,
++ AV_CODEC_ID_ADPCM_IMA_DK3,
++ AV_CODEC_ID_ADPCM_IMA_DK4,
++ AV_CODEC_ID_ADPCM_IMA_WS,
++ AV_CODEC_ID_ADPCM_IMA_SMJPEG,
++ AV_CODEC_ID_ADPCM_MS,
++ AV_CODEC_ID_ADPCM_4XM,
++ AV_CODEC_ID_ADPCM_XA,
++ AV_CODEC_ID_ADPCM_ADX,
++ AV_CODEC_ID_ADPCM_EA,
++ AV_CODEC_ID_ADPCM_G726,
++ AV_CODEC_ID_ADPCM_CT,
++ AV_CODEC_ID_ADPCM_SWF,
++ AV_CODEC_ID_ADPCM_YAMAHA,
++ AV_CODEC_ID_ADPCM_SBPRO_4,
++ AV_CODEC_ID_ADPCM_SBPRO_3,
++ AV_CODEC_ID_ADPCM_SBPRO_2,
++ AV_CODEC_ID_ADPCM_THP,
++ AV_CODEC_ID_ADPCM_IMA_AMV,
++ AV_CODEC_ID_ADPCM_EA_R1,
++ AV_CODEC_ID_ADPCM_EA_R3,
++ AV_CODEC_ID_ADPCM_EA_R2,
++ AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
++ AV_CODEC_ID_ADPCM_IMA_EA_EACS,
++ AV_CODEC_ID_ADPCM_EA_XAS,
++ AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
++ AV_CODEC_ID_ADPCM_IMA_ISS,
++ AV_CODEC_ID_ADPCM_G722,
++ AV_CODEC_ID_ADPCM_IMA_APC,
++ AV_CODEC_ID_ADPCM_VIMA,
++ AV_CODEC_ID_ADPCM_AFC,
++ AV_CODEC_ID_ADPCM_IMA_OKI,
++ AV_CODEC_ID_ADPCM_DTK,
++ AV_CODEC_ID_ADPCM_IMA_RAD,
++ AV_CODEC_ID_ADPCM_G726LE,
++ AV_CODEC_ID_ADPCM_THP_LE,
++ AV_CODEC_ID_ADPCM_PSX,
++ AV_CODEC_ID_ADPCM_AICA,
++ AV_CODEC_ID_ADPCM_IMA_DAT4,
++ AV_CODEC_ID_ADPCM_MTAF,
++ AV_CODEC_ID_ADPCM_AGM,
++ AV_CODEC_ID_ADPCM_ARGO,
++ AV_CODEC_ID_ADPCM_IMA_SSI,
++ AV_CODEC_ID_ADPCM_ZORK,
++ AV_CODEC_ID_ADPCM_IMA_APM,
++ AV_CODEC_ID_ADPCM_IMA_ALP,
++ AV_CODEC_ID_ADPCM_IMA_MTF,
++ AV_CODEC_ID_ADPCM_IMA_CUNNING,
++ AV_CODEC_ID_ADPCM_IMA_MOFLEX,
++ AV_CODEC_ID_ADPCM_IMA_ACORN,
++ AV_CODEC_ID_ADPCM_XMD,
++
++ AV_CODEC_ID_AMR_NB = 0x12000,
++ AV_CODEC_ID_AMR_WB,
++
++ AV_CODEC_ID_RA_144 = 0x13000,
++ AV_CODEC_ID_RA_288,
++
++ AV_CODEC_ID_ROQ_DPCM = 0x14000,
++ AV_CODEC_ID_INTERPLAY_DPCM,
++ AV_CODEC_ID_XAN_DPCM,
++ AV_CODEC_ID_SOL_DPCM,
++ AV_CODEC_ID_SDX2_DPCM,
++ AV_CODEC_ID_GREMLIN_DPCM,
++ AV_CODEC_ID_DERF_DPCM,
++ AV_CODEC_ID_WADY_DPCM,
++ AV_CODEC_ID_CBD2_DPCM,
++
++ AV_CODEC_ID_MP2 = 0x15000,
++ AV_CODEC_ID_MP3,
++ AV_CODEC_ID_AAC,
++ AV_CODEC_ID_AC3,
++ AV_CODEC_ID_DTS,
++ AV_CODEC_ID_VORBIS,
++ AV_CODEC_ID_DVAUDIO,
++ AV_CODEC_ID_WMAV1,
++ AV_CODEC_ID_WMAV2,
++ AV_CODEC_ID_MACE3,
++ AV_CODEC_ID_MACE6,
++ AV_CODEC_ID_VMDAUDIO,
++ AV_CODEC_ID_FLAC,
++ AV_CODEC_ID_MP3ADU,
++ AV_CODEC_ID_MP3ON4,
++ AV_CODEC_ID_SHORTEN,
++ AV_CODEC_ID_ALAC,
++ AV_CODEC_ID_WESTWOOD_SND1,
++ AV_CODEC_ID_GSM,
++ AV_CODEC_ID_QDM2,
++ AV_CODEC_ID_COOK,
++ AV_CODEC_ID_TRUESPEECH,
++ AV_CODEC_ID_TTA,
++ AV_CODEC_ID_SMACKAUDIO,
++ AV_CODEC_ID_QCELP,
++ AV_CODEC_ID_WAVPACK,
++ AV_CODEC_ID_DSICINAUDIO,
++ AV_CODEC_ID_IMC,
++ AV_CODEC_ID_MUSEPACK7,
++ AV_CODEC_ID_MLP,
++ AV_CODEC_ID_GSM_MS,
++ AV_CODEC_ID_ATRAC3,
++ AV_CODEC_ID_APE,
++ AV_CODEC_ID_NELLYMOSER,
++ AV_CODEC_ID_MUSEPACK8,
++ AV_CODEC_ID_SPEEX,
++ AV_CODEC_ID_WMAVOICE,
++ AV_CODEC_ID_WMAPRO,
++ AV_CODEC_ID_WMALOSSLESS,
++ AV_CODEC_ID_ATRAC3P,
++ AV_CODEC_ID_EAC3,
++ AV_CODEC_ID_SIPR,
++ AV_CODEC_ID_MP1,
++ AV_CODEC_ID_TWINVQ,
++ AV_CODEC_ID_TRUEHD,
++ AV_CODEC_ID_MP4ALS,
++ AV_CODEC_ID_ATRAC1,
++ AV_CODEC_ID_BINKAUDIO_RDFT,
++ AV_CODEC_ID_BINKAUDIO_DCT,
++ AV_CODEC_ID_AAC_LATM,
++ AV_CODEC_ID_QDMC,
++ AV_CODEC_ID_CELT,
++ AV_CODEC_ID_G723_1,
++ AV_CODEC_ID_G729,
++ AV_CODEC_ID_8SVX_EXP,
++ AV_CODEC_ID_8SVX_FIB,
++ AV_CODEC_ID_BMV_AUDIO,
++ AV_CODEC_ID_RALF,
++ AV_CODEC_ID_IAC,
++ AV_CODEC_ID_ILBC,
++ AV_CODEC_ID_OPUS,
++ AV_CODEC_ID_COMFORT_NOISE,
++ AV_CODEC_ID_TAK,
++ AV_CODEC_ID_METASOUND,
++ AV_CODEC_ID_PAF_AUDIO,
++ AV_CODEC_ID_ON2AVC,
++ AV_CODEC_ID_DSS_SP,
++ AV_CODEC_ID_CODEC2,
++ AV_CODEC_ID_FFWAVESYNTH,
++ AV_CODEC_ID_SONIC,
++ AV_CODEC_ID_SONIC_LS,
++ AV_CODEC_ID_EVRC,
++ AV_CODEC_ID_SMV,
++ AV_CODEC_ID_DSD_LSBF,
++ AV_CODEC_ID_DSD_MSBF,
++ AV_CODEC_ID_DSD_LSBF_PLANAR,
++ AV_CODEC_ID_DSD_MSBF_PLANAR,
++ AV_CODEC_ID_4GV,
++ AV_CODEC_ID_INTERPLAY_ACM,
++ AV_CODEC_ID_XMA1,
++ AV_CODEC_ID_XMA2,
++ AV_CODEC_ID_DST,
++ AV_CODEC_ID_ATRAC3AL,
++ AV_CODEC_ID_ATRAC3PAL,
++ AV_CODEC_ID_DOLBY_E,
++ AV_CODEC_ID_APTX,
++ AV_CODEC_ID_APTX_HD,
++ AV_CODEC_ID_SBC,
++ AV_CODEC_ID_ATRAC9,
++ AV_CODEC_ID_HCOM,
++ AV_CODEC_ID_ACELP_KELVIN,
++ AV_CODEC_ID_MPEGH_3D_AUDIO,
++ AV_CODEC_ID_SIREN,
++ AV_CODEC_ID_HCA,
++ AV_CODEC_ID_FASTAUDIO,
++ AV_CODEC_ID_MSNSIREN,
++ AV_CODEC_ID_DFPWM,
++ AV_CODEC_ID_BONK,
++ AV_CODEC_ID_MISC4,
++ AV_CODEC_ID_APAC,
++ AV_CODEC_ID_FTR,
++ AV_CODEC_ID_WAVARC,
++ AV_CODEC_ID_RKA,
++
++ AV_CODEC_ID_FIRST_SUBTITLE = 0x17000,
++ AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
++ AV_CODEC_ID_DVB_SUBTITLE,
++ AV_CODEC_ID_TEXT,
++ AV_CODEC_ID_XSUB,
++ AV_CODEC_ID_SSA,
++ AV_CODEC_ID_MOV_TEXT,
++ AV_CODEC_ID_HDMV_PGS_SUBTITLE,
++ AV_CODEC_ID_DVB_TELETEXT,
++ AV_CODEC_ID_SRT,
++ AV_CODEC_ID_MICRODVD,
++ AV_CODEC_ID_EIA_608,
++ AV_CODEC_ID_JACOSUB,
++ AV_CODEC_ID_SAMI,
++ AV_CODEC_ID_REALTEXT,
++ AV_CODEC_ID_STL,
++ AV_CODEC_ID_SUBVIEWER1,
++ AV_CODEC_ID_SUBVIEWER,
++ AV_CODEC_ID_SUBRIP,
++ AV_CODEC_ID_WEBVTT,
++ AV_CODEC_ID_MPL2,
++ AV_CODEC_ID_VPLAYER,
++ AV_CODEC_ID_PJS,
++ AV_CODEC_ID_ASS,
++ AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
++ AV_CODEC_ID_TTML,
++ AV_CODEC_ID_ARIB_CAPTION,
++
++ AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,
++ AV_CODEC_ID_TTF = 0x18000,
++
++ AV_CODEC_ID_SCTE_35,
++ AV_CODEC_ID_EPG,
++ AV_CODEC_ID_BINTEXT,
++ AV_CODEC_ID_XBIN,
++ AV_CODEC_ID_IDF,
++ AV_CODEC_ID_OTF,
++ AV_CODEC_ID_SMPTE_KLV,
++ AV_CODEC_ID_DVD_NAV,
++ AV_CODEC_ID_TIMED_ID3,
++ AV_CODEC_ID_BIN_DATA,
++
++ AV_CODEC_ID_PROBE = 0x19000,
++
++ AV_CODEC_ID_MPEG2TS = 0x20000,
++
++ AV_CODEC_ID_MPEG4SYSTEMS = 0x20001,
++
++ AV_CODEC_ID_FFMETADATA = 0x21000,
++ AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001,
++
++ AV_CODEC_ID_VNULL,
++
++ AV_CODEC_ID_ANULL,
++};
++
++enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
++
++const char *avcodec_get_name(enum AVCodecID id);
++
++int av_get_bits_per_sample(enum AVCodecID codec_id);
++
++int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
++
++const char *avcodec_profile_name(enum AVCodecID codec_id, int profile);
++
++enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
++
++#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
++
++#define AV_CODEC_CAP_DR1 (1 << 1)
++
++#define AV_CODEC_CAP_DELAY (1 << 5)
++
++#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
++
++#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
++
++#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
++
++#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
++
++#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
++
++#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
++
++#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
++
++#define AV_CODEC_CAP_OTHER_THREADS (1 << 15)
++
++#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
++
++#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
++
++#define AV_CODEC_CAP_HARDWARE (1 << 18)
++
++#define AV_CODEC_CAP_HYBRID (1 << 19)
++
++#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
++
++#define AV_CODEC_CAP_ENCODER_FLUSH (1 << 21)
++
++#define AV_CODEC_CAP_ENCODER_RECON_FRAME (1 << 22)
++
++typedef struct AVProfile {
++ int profile;
++ const char *name;
++} AVProfile;
++
++typedef struct AVCodec {
++
++ const char *name;
++
++ const char *long_name;
++ enum AVMediaType type;
++ enum AVCodecID id;
++
++ int capabilities;
++ uint8_t max_lowres;
++ const AVRational *supported_framerates;
++ const enum AVPixelFormat *pix_fmts;
++ const int *supported_samplerates;
++ const enum AVSampleFormat *sample_fmts;
++
++ attribute_deprecated
++ const uint64_t *channel_layouts;
++ const AVClass *priv_class;
++ const AVProfile *profiles;
++
++ const char *wrapper_name;
++
++ const AVChannelLayout *ch_layouts;
++} AVCodec;
++
++const AVCodec *av_codec_iterate(void **opaque);
++
++const AVCodec *avcodec_find_decoder(enum AVCodecID id);
++
++const AVCodec *avcodec_find_decoder_by_name(const char *name);
++
++const AVCodec *avcodec_find_encoder(enum AVCodecID id);
++
++const AVCodec *avcodec_find_encoder_by_name(const char *name);
++
++int av_codec_is_encoder(const AVCodec *codec);
++
++int av_codec_is_decoder(const AVCodec *codec);
++
++const char *av_get_profile_name(const AVCodec *codec, int profile);
++
++enum {
++
++ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
++
++ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
++
++ AV_CODEC_HW_CONFIG_METHOD_INTERNAL = 0x04,
++
++ AV_CODEC_HW_CONFIG_METHOD_AD_HOC = 0x08,
++};
++
++typedef struct AVCodecHWConfig {
++
++ enum AVPixelFormat pix_fmt;
++
++ int methods;
++
++ enum AVHWDeviceType device_type;
++} AVCodecHWConfig;
++
++const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
++
++#define AVCODEC_CODEC_DESC_H
++
++typedef struct AVCodecDescriptor {
++ enum AVCodecID id;
++ enum AVMediaType type;
++
++ const char *name;
++
++ const char *long_name;
++
++ int props;
++
++ const char *const *mime_types;
++
++ const struct AVProfile *profiles;
++} AVCodecDescriptor;
++
++#define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
++
++#define AV_CODEC_PROP_LOSSY (1 << 1)
++
++#define AV_CODEC_PROP_LOSSLESS (1 << 2)
++
++#define AV_CODEC_PROP_REORDER (1 << 3)
++
++#define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
++
++#define AV_CODEC_PROP_TEXT_SUB (1 << 17)
++
++const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
++
++const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
++
++const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
++
++#define AVCODEC_CODEC_PAR_H
++
++enum AVFieldOrder {
++ AV_FIELD_UNKNOWN,
++ AV_FIELD_PROGRESSIVE,
++ AV_FIELD_TT,
++ AV_FIELD_BB,
++ AV_FIELD_TB,
++ AV_FIELD_BT,
++};
++
++typedef struct AVCodecParameters {
++
++ enum AVMediaType codec_type;
++
++ enum AVCodecID codec_id;
++
++ uint32_t codec_tag;
++
++ uint8_t *extradata;
++
++ int extradata_size;
++
++ int format;
++
++ int64_t bit_rate;
++
++ int bits_per_coded_sample;
++
++ int bits_per_raw_sample;
++
++ int profile;
++ int level;
++
++ int width;
++ int height;
++
++ AVRational sample_aspect_ratio;
++
++ enum AVFieldOrder field_order;
++
++ enum AVColorRange color_range;
++ enum AVColorPrimaries color_primaries;
++ enum AVColorTransferCharacteristic color_trc;
++ enum AVColorSpace color_space;
++ enum AVChromaLocation chroma_location;
++
++ int video_delay;
++
++ attribute_deprecated
++ uint64_t channel_layout;
++
++ attribute_deprecated
++ int channels;
++
++ int sample_rate;
++
++ int block_align;
++
++ int frame_size;
++
++ int initial_padding;
++
++ int trailing_padding;
++
++ int seek_preroll;
++
++ AVChannelLayout ch_layout;
++} AVCodecParameters;
++
++AVCodecParameters *avcodec_parameters_alloc(void);
++
++void avcodec_parameters_free(AVCodecParameters **par);
++
++int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);
++
++int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes);
++
++#define AVCODEC_DEFS_H
++
++#define AV_INPUT_BUFFER_PADDING_SIZE 64
++
++#define AV_EF_CRCCHECK (1<<0)
++#define AV_EF_BITSTREAM (1<<1)
++#define AV_EF_BUFFER (1<<2)
++#define AV_EF_EXPLODE (1<<3)
++
++#define AV_EF_IGNORE_ERR (1<<15)
++#define AV_EF_CAREFUL (1<<16)
++#define AV_EF_COMPLIANT (1<<17)
++#define AV_EF_AGGRESSIVE (1<<18)
++
++#define FF_COMPLIANCE_VERY_STRICT 2
++#define FF_COMPLIANCE_STRICT 1
++#define FF_COMPLIANCE_NORMAL 0
++#define FF_COMPLIANCE_UNOFFICIAL -1
++#define FF_COMPLIANCE_EXPERIMENTAL -2
++
++enum AVDiscard{
++
++ AVDISCARD_NONE =-16,
++ AVDISCARD_DEFAULT = 0,
++ AVDISCARD_NONREF = 8,
++ AVDISCARD_BIDIR = 16,
++ AVDISCARD_NONINTRA= 24,
++ AVDISCARD_NONKEY = 32,
++ AVDISCARD_ALL = 48,
++};
++
++enum AVAudioServiceType {
++ AV_AUDIO_SERVICE_TYPE_MAIN = 0,
++ AV_AUDIO_SERVICE_TYPE_EFFECTS = 1,
++ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
++ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3,
++ AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4,
++ AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5,
++ AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6,
++ AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7,
++ AV_AUDIO_SERVICE_TYPE_KARAOKE = 8,
++ AV_AUDIO_SERVICE_TYPE_NB ,
++};
++
++typedef struct AVPanScan {
++
++ int id;
++
++ int width;
++ int height;
++
++ int16_t position[3][2];
++} AVPanScan;
++
++typedef struct AVCPBProperties {
++
++ int64_t max_bitrate;
++
++ int64_t min_bitrate;
++
++ int64_t avg_bitrate;
++
++ int64_t buffer_size;
++
++ uint64_t vbv_delay;
++} AVCPBProperties;
++
++AVCPBProperties *av_cpb_properties_alloc(size_t *size);
++
++typedef struct AVProducerReferenceTime {
++
++ int64_t wallclock;
++ int flags;
++} AVProducerReferenceTime;
++
++unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
++
++#define AVCODEC_PACKET_H
++
++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_NB
++};
++
++#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS
++
++typedef struct AVPacketSideData {
++ uint8_t *data;
++ size_t size;
++ enum AVPacketSideDataType type;
++} AVPacketSideData;
++
++typedef struct AVPacket {
++
++ AVBufferRef *buf;
++
++ int64_t pts;
++
++ int64_t dts;
++ uint8_t *data;
++ int size;
++ int stream_index;
++
++ int flags;
++
++ AVPacketSideData *side_data;
++ int side_data_elems;
++
++ int64_t duration;
++
++ int64_t pos;
++
++ void *opaque;
++
++ AVBufferRef *opaque_ref;
++
++ AVRational time_base;
++} AVPacket;
++
++attribute_deprecated
++typedef struct AVPacketList {
++ AVPacket pkt;
++ struct AVPacketList *next;
++} AVPacketList;
++
++#define AV_PKT_FLAG_KEY 0x0001
++#define AV_PKT_FLAG_CORRUPT 0x0002
++
++#define AV_PKT_FLAG_DISCARD 0x0004
++
++#define AV_PKT_FLAG_TRUSTED 0x0008
++
++#define AV_PKT_FLAG_DISPOSABLE 0x0010
++
++enum AVSideDataParamChangeFlags {
++
++ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001,
++ AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
++ AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
++ AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
++};
++
++AVPacket *av_packet_alloc(void);
++
++AVPacket *av_packet_clone(const AVPacket *src);
++
++void av_packet_free(AVPacket **pkt);
++
++attribute_deprecated
++void av_init_packet(AVPacket *pkt);
++
++int av_new_packet(AVPacket *pkt, int size);
++
++void av_shrink_packet(AVPacket *pkt, int size);
++
++int av_grow_packet(AVPacket *pkt, int grow_by);
++
++int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
++
++uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
++ size_t size);
++
++int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
++ uint8_t *data, size_t size);
++
++int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
++ size_t size);
++
++uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
++ size_t *size);
++
++const char *av_packet_side_data_name(enum AVPacketSideDataType type);
++
++uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size);
++
++int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
++ AVDictionary **dict);
++
++void av_packet_free_side_data(AVPacket *pkt);
++
++int av_packet_ref(AVPacket *dst, const AVPacket *src);
++
++void av_packet_unref(AVPacket *pkt);
++
++void av_packet_move_ref(AVPacket *dst, AVPacket *src);
++
++int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
++
++int av_packet_make_refcounted(AVPacket *pkt);
++
++int av_packet_make_writable(AVPacket *pkt);
++
++void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
++
++#define AVCODEC_VERSION_H
++
++#define LIBAVCODEC_VERSION_MINOR 3
++#define LIBAVCODEC_VERSION_MICRO 100
++
++#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
++ LIBAVCODEC_VERSION_MINOR, \
++ LIBAVCODEC_VERSION_MICRO)
++#define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \
++ LIBAVCODEC_VERSION_MINOR, \
++ LIBAVCODEC_VERSION_MICRO)
++#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT
++
++#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
++
++#define AV_INPUT_BUFFER_MIN_SIZE 16384
++
++typedef struct RcOverride{
++ int start_frame;
++ int end_frame;
++ int qscale;
++ float quality_factor;
++} RcOverride;
++
++#define AV_CODEC_FLAG_UNALIGNED (1 << 0)
++
++#define AV_CODEC_FLAG_QSCALE (1 << 1)
++
++#define AV_CODEC_FLAG_4MV (1 << 2)
++
++#define AV_CODEC_FLAG_OUTPUT_CORRUPT (1 << 3)
++
++#define AV_CODEC_FLAG_QPEL (1 << 4)
++
++#define AV_CODEC_FLAG_DROPCHANGED (1 << 5)
++
++#define AV_CODEC_FLAG_RECON_FRAME (1 << 6)
++
++#define AV_CODEC_FLAG_COPY_OPAQUE (1 << 7)
++
++#define AV_CODEC_FLAG_FRAME_DURATION (1 << 8)
++
++#define AV_CODEC_FLAG_PASS1 (1 << 9)
++
++#define AV_CODEC_FLAG_PASS2 (1 << 10)
++
++#define AV_CODEC_FLAG_LOOP_FILTER (1 << 11)
++
++#define AV_CODEC_FLAG_GRAY (1 << 13)
++
++#define AV_CODEC_FLAG_PSNR (1 << 15)
++
++#define AV_CODEC_FLAG_INTERLACED_DCT (1 << 18)
++
++#define AV_CODEC_FLAG_LOW_DELAY (1 << 19)
++
++#define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22)
++
++#define AV_CODEC_FLAG_BITEXACT (1 << 23)
++
++#define AV_CODEC_FLAG_AC_PRED (1 << 24)
++
++#define AV_CODEC_FLAG_INTERLACED_ME (1 << 29)
++#define AV_CODEC_FLAG_CLOSED_GOP (1U << 31)
++
++#define AV_CODEC_FLAG2_FAST (1 << 0)
++
++#define AV_CODEC_FLAG2_NO_OUTPUT (1 << 2)
++
++#define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3)
++
++#define AV_CODEC_FLAG2_CHUNKS (1 << 15)
++
++#define AV_CODEC_FLAG2_IGNORE_CROP (1 << 16)
++
++#define AV_CODEC_FLAG2_SHOW_ALL (1 << 22)
++
++#define AV_CODEC_FLAG2_EXPORT_MVS (1 << 28)
++
++#define AV_CODEC_FLAG2_SKIP_MANUAL (1 << 29)
++
++#define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30)
++
++#define AV_CODEC_FLAG2_ICC_PROFILES (1U << 31)
++
++#define AV_CODEC_EXPORT_DATA_MVS (1 << 0)
++
++#define AV_CODEC_EXPORT_DATA_PRFT (1 << 1)
++
++#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS (1 << 2)
++
++#define AV_CODEC_EXPORT_DATA_FILM_GRAIN (1 << 3)
++
++#define AV_GET_BUFFER_FLAG_REF (1 << 0)
++
++#define AV_GET_ENCODE_BUFFER_FLAG_REF (1 << 0)
++
++struct AVCodecInternal;
++
++typedef struct AVCodecContext {
++
++ const AVClass *av_class;
++ int log_level_offset;
++
++ enum AVMediaType codec_type;
++ const struct AVCodec *codec;
++ enum AVCodecID codec_id;
++
++ unsigned int codec_tag;
++
++ void *priv_data;
++
++ struct AVCodecInternal *internal;
++
++ void *opaque;
++
++ int64_t bit_rate;
++
++ int bit_rate_tolerance;
++
++ int global_quality;
++
++ int compression_level;
++#define FF_COMPRESSION_DEFAULT -1
++
++ int flags;
++
++ int flags2;
++
++ uint8_t *extradata;
++ int extradata_size;
++
++ AVRational time_base;
++
++ int ticks_per_frame;
++
++ int delay;
++
++ int width, height;
++
++ int coded_width, coded_height;
++
++ int gop_size;
++
++ enum AVPixelFormat pix_fmt;
++
++ void (*draw_horiz_band)(struct AVCodecContext *s,
++ const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
++ int y, int type, int height);
++
++ enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
++
++ int max_b_frames;
++
++ float b_quant_factor;
++
++ float b_quant_offset;
++
++ int has_b_frames;
++
++ float i_quant_factor;
++
++ float i_quant_offset;
++
++ float lumi_masking;
++
++ float temporal_cplx_masking;
++
++ float spatial_cplx_masking;
++
++ float p_masking;
++
++ float dark_masking;
++
++ int slice_count;
++
++ int *slice_offset;
++
++ AVRational sample_aspect_ratio;
++
++ int me_cmp;
++
++ int me_sub_cmp;
++
++ int mb_cmp;
++
++ int ildct_cmp;
++#define FF_CMP_SAD 0
++#define FF_CMP_SSE 1
++#define FF_CMP_SATD 2
++#define FF_CMP_DCT 3
++#define FF_CMP_PSNR 4
++#define FF_CMP_BIT 5
++#define FF_CMP_RD 6
++#define FF_CMP_ZERO 7
++#define FF_CMP_VSAD 8
++#define FF_CMP_VSSE 9
++#define FF_CMP_NSSE 10
++#define FF_CMP_W53 11
++#define FF_CMP_W97 12
++#define FF_CMP_DCTMAX 13
++#define FF_CMP_DCT264 14
++#define FF_CMP_MEDIAN_SAD 15
++#define FF_CMP_CHROMA 256
++
++ int dia_size;
++
++ int last_predictor_count;
++
++ int me_pre_cmp;
++
++ int pre_dia_size;
++
++ int me_subpel_quality;
++
++ int me_range;
++
++ int slice_flags;
++#define SLICE_FLAG_CODED_ORDER 0x0001
++#define SLICE_FLAG_ALLOW_FIELD 0x0002
++#define SLICE_FLAG_ALLOW_PLANE 0x0004
++
++ int mb_decision;
++#define FF_MB_DECISION_SIMPLE 0
++#define FF_MB_DECISION_BITS 1
++#define FF_MB_DECISION_RD 2
++
++ uint16_t *intra_matrix;
++
++ uint16_t *inter_matrix;
++
++ int intra_dc_precision;
++
++ int skip_top;
++
++ int skip_bottom;
++
++ int mb_lmin;
++
++ int mb_lmax;
++
++ int bidir_refine;
++
++ int keyint_min;
++
++ int refs;
++
++ int mv0_threshold;
++
++ enum AVColorPrimaries color_primaries;
++
++ enum AVColorTransferCharacteristic color_trc;
++
++ enum AVColorSpace colorspace;
++
++ enum AVColorRange color_range;
++
++ enum AVChromaLocation chroma_sample_location;
++
++ int slices;
++
++ enum AVFieldOrder field_order;
++
++ int sample_rate;
++
++ attribute_deprecated
++ int channels;
++
++ enum AVSampleFormat sample_fmt;
++
++ int frame_size;
++
++ attribute_deprecated
++ int frame_number;
++
++ int block_align;
++
++ int cutoff;
++
++ attribute_deprecated
++ uint64_t channel_layout;
++
++ attribute_deprecated
++ uint64_t request_channel_layout;
++
++ enum AVAudioServiceType audio_service_type;
++
++ enum AVSampleFormat request_sample_fmt;
++
++ int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);
++
++ float qcompress;
++ float qblur;
++
++ int qmin;
++
++ int qmax;
++
++ int max_qdiff;
++
++ int rc_buffer_size;
++
++ int rc_override_count;
++ RcOverride *rc_override;
++
++ int64_t rc_max_rate;
++
++ int64_t rc_min_rate;
++
++ float rc_max_available_vbv_use;
++
++ float rc_min_vbv_overflow_use;
++
++ int rc_initial_buffer_occupancy;
++
++ int trellis;
++
++ char *stats_out;
++
++ char *stats_in;
++
++ int workaround_bugs;
++#define FF_BUG_AUTODETECT 1
++#define FF_BUG_XVID_ILACE 4
++#define FF_BUG_UMP4 8
++#define FF_BUG_NO_PADDING 16
++#define FF_BUG_AMV 32
++#define FF_BUG_QPEL_CHROMA 64
++#define FF_BUG_STD_QPEL 128
++#define FF_BUG_QPEL_CHROMA2 256
++#define FF_BUG_DIRECT_BLOCKSIZE 512
++#define FF_BUG_EDGE 1024
++#define FF_BUG_HPEL_CHROMA 2048
++#define FF_BUG_DC_CLIP 4096
++#define FF_BUG_MS 8192
++#define FF_BUG_TRUNCATED 16384
++#define FF_BUG_IEDGE 32768
++
++ int strict_std_compliance;
++
++ int error_concealment;
++#define FF_EC_GUESS_MVS 1
++#define FF_EC_DEBLOCK 2
++#define FF_EC_FAVOR_INTER 256
++
++ int debug;
++#define FF_DEBUG_PICT_INFO 1
++#define FF_DEBUG_RC 2
++#define FF_DEBUG_BITSTREAM 4
++#define FF_DEBUG_MB_TYPE 8
++#define FF_DEBUG_QP 16
++#define FF_DEBUG_DCT_COEFF 0x00000040
++#define FF_DEBUG_SKIP 0x00000080
++#define FF_DEBUG_STARTCODE 0x00000100
++#define FF_DEBUG_ER 0x00000400
++#define FF_DEBUG_MMCO 0x00000800
++#define FF_DEBUG_BUGS 0x00001000
++#define FF_DEBUG_BUFFERS 0x00008000
++#define FF_DEBUG_THREADS 0x00010000
++#define FF_DEBUG_GREEN_MD 0x00800000
++#define FF_DEBUG_NOMC 0x01000000
++
++ int err_recognition;
++
++ attribute_deprecated
++ int64_t reordered_opaque;
++
++ const struct AVHWAccel *hwaccel;
++
++ void *hwaccel_context;
++
++ uint64_t error[AV_NUM_DATA_POINTERS];
++
++ int dct_algo;
++#define FF_DCT_AUTO 0
++#define FF_DCT_FASTINT 1
++#define FF_DCT_INT 2
++#define FF_DCT_MMX 3
++#define FF_DCT_ALTIVEC 5
++#define FF_DCT_FAAN 6
++
++ int idct_algo;
++#define FF_IDCT_AUTO 0
++#define FF_IDCT_INT 1
++#define FF_IDCT_SIMPLE 2
++#define FF_IDCT_SIMPLEMMX 3
++#define FF_IDCT_ARM 7
++#define FF_IDCT_ALTIVEC 8
++#define FF_IDCT_SIMPLEARM 10
++#define FF_IDCT_XVID 14
++#define FF_IDCT_SIMPLEARMV5TE 16
++#define FF_IDCT_SIMPLEARMV6 17
++#define FF_IDCT_FAAN 20
++#define FF_IDCT_SIMPLENEON 22
++
++#define FF_IDCT_NONE 24
++#define FF_IDCT_SIMPLEAUTO 128
++
++ int bits_per_coded_sample;
++
++ int bits_per_raw_sample;
++
++ int lowres;
++
++ int thread_count;
++
++ int thread_type;
++#define FF_THREAD_FRAME 1
++#define FF_THREAD_SLICE 2
++
++ int active_thread_type;
++
++ int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
++
++ int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count);
++
++ int nsse_weight;
++
++ int profile;
++#define FF_PROFILE_UNKNOWN -99
++#define FF_PROFILE_RESERVED -100
++
++#define FF_PROFILE_AAC_MAIN 0
++#define FF_PROFILE_AAC_LOW 1
++#define FF_PROFILE_AAC_SSR 2
++#define FF_PROFILE_AAC_LTP 3
++#define FF_PROFILE_AAC_HE 4
++#define FF_PROFILE_AAC_HE_V2 28
++#define FF_PROFILE_AAC_LD 22
++#define FF_PROFILE_AAC_ELD 38
++#define FF_PROFILE_MPEG2_AAC_LOW 128
++#define FF_PROFILE_MPEG2_AAC_HE 131
++
++#define FF_PROFILE_DNXHD 0
++#define FF_PROFILE_DNXHR_LB 1
++#define FF_PROFILE_DNXHR_SQ 2
++#define FF_PROFILE_DNXHR_HQ 3
++#define FF_PROFILE_DNXHR_HQX 4
++#define FF_PROFILE_DNXHR_444 5
++
++#define FF_PROFILE_DTS 20
++#define FF_PROFILE_DTS_ES 30
++#define FF_PROFILE_DTS_96_24 40
++#define FF_PROFILE_DTS_HD_HRA 50
++#define FF_PROFILE_DTS_HD_MA 60
++#define FF_PROFILE_DTS_EXPRESS 70
++
++#define FF_PROFILE_MPEG2_422 0
++#define FF_PROFILE_MPEG2_HIGH 1
++#define FF_PROFILE_MPEG2_SS 2
++#define FF_PROFILE_MPEG2_SNR_SCALABLE 3
++#define FF_PROFILE_MPEG2_MAIN 4
++#define FF_PROFILE_MPEG2_SIMPLE 5
++
++#define FF_PROFILE_H264_CONSTRAINED (1<<9)
++#define FF_PROFILE_H264_INTRA (1<<11)
++
++#define FF_PROFILE_H264_BASELINE 66
++#define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
++#define FF_PROFILE_H264_MAIN 77
++#define FF_PROFILE_H264_EXTENDED 88
++#define FF_PROFILE_H264_HIGH 100
++#define FF_PROFILE_H264_HIGH_10 110
++#define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA)
++#define FF_PROFILE_H264_MULTIVIEW_HIGH 118
++#define FF_PROFILE_H264_HIGH_422 122
++#define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA)
++#define FF_PROFILE_H264_STEREO_HIGH 128
++#define FF_PROFILE_H264_HIGH_444 144
++#define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244
++#define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA)
++#define FF_PROFILE_H264_CAVLC_444 44
++
++#define FF_PROFILE_VC1_SIMPLE 0
++#define FF_PROFILE_VC1_MAIN 1
++#define FF_PROFILE_VC1_COMPLEX 2
++#define FF_PROFILE_VC1_ADVANCED 3
++
++#define FF_PROFILE_MPEG4_SIMPLE 0
++#define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1
++#define FF_PROFILE_MPEG4_CORE 2
++#define FF_PROFILE_MPEG4_MAIN 3
++#define FF_PROFILE_MPEG4_N_BIT 4
++#define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5
++#define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6
++#define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7
++#define FF_PROFILE_MPEG4_HYBRID 8
++#define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9
++#define FF_PROFILE_MPEG4_CORE_SCALABLE 10
++#define FF_PROFILE_MPEG4_ADVANCED_CODING 11
++#define FF_PROFILE_MPEG4_ADVANCED_CORE 12
++#define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
++#define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14
++#define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15
++
++#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 1
++#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 2
++#define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 32768
++#define FF_PROFILE_JPEG2000_DCINEMA_2K 3
++#define FF_PROFILE_JPEG2000_DCINEMA_4K 4
++
++#define FF_PROFILE_VP9_0 0
++#define FF_PROFILE_VP9_1 1
++#define FF_PROFILE_VP9_2 2
++#define FF_PROFILE_VP9_3 3
++
++#define FF_PROFILE_HEVC_MAIN 1
++#define FF_PROFILE_HEVC_MAIN_10 2
++#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3
++#define FF_PROFILE_HEVC_REXT 4
++
++#define FF_PROFILE_VVC_MAIN_10 1
++#define FF_PROFILE_VVC_MAIN_10_444 33
++
++#define FF_PROFILE_AV1_MAIN 0
++#define FF_PROFILE_AV1_HIGH 1
++#define FF_PROFILE_AV1_PROFESSIONAL 2
++
++#define FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT 0xc0
++#define FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT 0xc1
++#define FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT 0xc2
++#define FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS 0xc3
++#define FF_PROFILE_MJPEG_JPEG_LS 0xf7
++
++#define FF_PROFILE_SBC_MSBC 1
++
++#define FF_PROFILE_PRORES_PROXY 0
++#define FF_PROFILE_PRORES_LT 1
++#define FF_PROFILE_PRORES_STANDARD 2
++#define FF_PROFILE_PRORES_HQ 3
++#define FF_PROFILE_PRORES_4444 4
++#define FF_PROFILE_PRORES_XQ 5
++
++#define FF_PROFILE_ARIB_PROFILE_A 0
++#define FF_PROFILE_ARIB_PROFILE_C 1
++
++#define FF_PROFILE_KLVA_SYNC 0
++#define FF_PROFILE_KLVA_ASYNC 1
++
++ int level;
++#define FF_LEVEL_UNKNOWN -99
++
++ enum AVDiscard skip_loop_filter;
++
++ enum AVDiscard skip_idct;
++
++ enum AVDiscard skip_frame;
++
++ uint8_t *subtitle_header;
++ int subtitle_header_size;
++
++ int initial_padding;
++
++ AVRational framerate;
++
++ enum AVPixelFormat sw_pix_fmt;
++
++ AVRational pkt_timebase;
++
++ const AVCodecDescriptor *codec_descriptor;
++
++ int64_t pts_correction_num_faulty_pts;
++ int64_t pts_correction_num_faulty_dts;
++ int64_t pts_correction_last_pts;
++ int64_t pts_correction_last_dts;
++
++ char *sub_charenc;
++
++ int sub_charenc_mode;
++#define FF_SUB_CHARENC_MODE_DO_NOTHING -1
++#define FF_SUB_CHARENC_MODE_AUTOMATIC 0
++#define FF_SUB_CHARENC_MODE_PRE_DECODER 1
++#define FF_SUB_CHARENC_MODE_IGNORE 2
++
++ int skip_alpha;
++
++ int seek_preroll;
++
++ uint16_t *chroma_intra_matrix;
++
++ uint8_t *dump_separator;
++
++ char *codec_whitelist;
++
++ unsigned properties;
++#define FF_CODEC_PROPERTY_LOSSLESS 0x00000001
++#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002
++#define FF_CODEC_PROPERTY_FILM_GRAIN 0x00000004
++
++ AVPacketSideData *coded_side_data;
++ int nb_coded_side_data;
++
++ AVBufferRef *hw_frames_ctx;
++
++ int trailing_padding;
++
++ int64_t max_pixels;
++
++ AVBufferRef *hw_device_ctx;
++
++ int hwaccel_flags;
++
++ int apply_cropping;
++
++ int extra_hw_frames;
++
++ int discard_damaged_percentage;
++
++ int64_t max_samples;
++
++ int export_side_data;
++
++ int (*get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags);
++
++ AVChannelLayout ch_layout;
++
++ int64_t frame_num;
++} AVCodecContext;
++
++typedef struct AVHWAccel {
++
++ const char *name;
++
++ enum AVMediaType type;
++
++ enum AVCodecID id;
++
++ enum AVPixelFormat pix_fmt;
++
++ int capabilities;
++
++ int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);
++
++ int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
++
++ int (*decode_params)(AVCodecContext *avctx, int type, const uint8_t *buf, uint32_t buf_size);
++
++ int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
++
++ int (*end_frame)(AVCodecContext *avctx);
++
++ int frame_priv_data_size;
++
++ int (*init)(AVCodecContext *avctx);
++
++ int (*uninit)(AVCodecContext *avctx);
++
++ int priv_data_size;
++
++ int caps_internal;
++
++ int (*frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx);
++} AVHWAccel;
++
++#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200
++
++#define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0)
++
++#define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1)
++
++#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2)
++
++#define AV_HWACCEL_FLAG_UNSAFE_OUTPUT (1 << 3)
++
++enum AVSubtitleType {
++ SUBTITLE_NONE,
++
++ SUBTITLE_BITMAP,
++
++ SUBTITLE_TEXT,
++
++ SUBTITLE_ASS,
++};
++
++#define AV_SUBTITLE_FLAG_FORCED 0x00000001
++
++typedef struct AVSubtitleRect {
++ int x;
++ int y;
++ int w;
++ int h;
++ int nb_colors;
++
++ uint8_t *data[4];
++ int linesize[4];
++
++ enum AVSubtitleType type;
++
++ char *text;
++
++ char *ass;
++
++ int flags;
++} AVSubtitleRect;
++
++typedef struct AVSubtitle {
++ uint16_t format;
++ uint32_t start_display_time;
++ uint32_t end_display_time;
++ unsigned num_rects;
++ AVSubtitleRect **rects;
++ int64_t pts;
++} AVSubtitle;
++
++unsigned avcodec_version(void);
++
++const char *avcodec_configuration(void);
++
++const char *avcodec_license(void);
++
++AVCodecContext *avcodec_alloc_context3(const AVCodec *codec);
++
++void avcodec_free_context(AVCodecContext **avctx);
++
++const AVClass *avcodec_get_class(void);
++
++const AVClass *avcodec_get_subtitle_rect_class(void);
++
++int avcodec_parameters_from_context(AVCodecParameters *par,
++ const AVCodecContext *codec);
++
++int avcodec_parameters_to_context(AVCodecContext *codec,
++ const AVCodecParameters *par);
++
++int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
++
++int avcodec_close(AVCodecContext *avctx);
++
++void avsubtitle_free(AVSubtitle *sub);
++
++int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags);
++
++int avcodec_default_get_encode_buffer(AVCodecContext *s, AVPacket *pkt, int flags);
++
++void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
++
++void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
++ int linesize_align[AV_NUM_DATA_POINTERS]);
++
++ attribute_deprecated
++int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
++
++ attribute_deprecated
++enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);
++
++int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
++ int *got_sub_ptr, const AVPacket *avpkt);
++
++int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt);
++
++int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);
++
++int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);
++
++int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt);
++
++int avcodec_get_hw_frames_parameters(AVCodecContext *avctx,
++ AVBufferRef *device_ref,
++ enum AVPixelFormat hw_pix_fmt,
++ AVBufferRef **out_frames_ref);
++
++enum AVPictureStructure {
++ AV_PICTURE_STRUCTURE_UNKNOWN,
++ AV_PICTURE_STRUCTURE_TOP_FIELD,
++ AV_PICTURE_STRUCTURE_BOTTOM_FIELD,
++ AV_PICTURE_STRUCTURE_FRAME,
++};
++
++typedef struct AVCodecParserContext {
++ void *priv_data;
++ const struct AVCodecParser *parser;
++ int64_t frame_offset;
++ int64_t cur_offset;
++
++ int64_t next_frame_offset;
++
++ int pict_type;
++
++ int repeat_pict;
++ int64_t pts;
++ int64_t dts;
++
++ int64_t last_pts;
++ int64_t last_dts;
++ int fetch_timestamp;
++
++#define AV_PARSER_PTS_NB 4
++ int cur_frame_start_index;
++ int64_t cur_frame_offset[AV_PARSER_PTS_NB];
++ int64_t cur_frame_pts[AV_PARSER_PTS_NB];
++ int64_t cur_frame_dts[AV_PARSER_PTS_NB];
++
++ int flags;
++#define PARSER_FLAG_COMPLETE_FRAMES 0x0001
++#define PARSER_FLAG_ONCE 0x0002
++
++#define PARSER_FLAG_FETCHED_OFFSET 0x0004
++#define PARSER_FLAG_USE_CODEC_TS 0x1000
++
++ int64_t offset;
++ int64_t cur_frame_end[AV_PARSER_PTS_NB];
++
++ int key_frame;
++
++ int dts_sync_point;
++
++ int dts_ref_dts_delta;
++
++ int pts_dts_delta;
++
++ int64_t cur_frame_pos[AV_PARSER_PTS_NB];
++
++ int64_t pos;
++
++ int64_t last_pos;
++
++ int duration;
++
++ enum AVFieldOrder field_order;
++
++ enum AVPictureStructure picture_structure;
++
++ int output_picture_number;
++
++ int width;
++ int height;
++
++ int coded_width;
++ int coded_height;
++
++ int format;
++} AVCodecParserContext;
++
++typedef struct AVCodecParser {
++ int codec_ids[7];
++ int priv_data_size;
++ int (*parser_init)(AVCodecParserContext *s);
++
++ int (*parser_parse)(AVCodecParserContext *s,
++ AVCodecContext *avctx,
++ const uint8_t **poutbuf, int *poutbuf_size,
++ const uint8_t *buf, int buf_size);
++ void (*parser_close)(AVCodecParserContext *s);
++ int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
++} AVCodecParser;
++
++const AVCodecParser *av_parser_iterate(void **opaque);
++
++AVCodecParserContext *av_parser_init(int codec_id);
++
++int av_parser_parse2(AVCodecParserContext *s,
++ AVCodecContext *avctx,
++ uint8_t **poutbuf, int *poutbuf_size,
++ const uint8_t *buf, int buf_size,
++ int64_t pts, int64_t dts,
++ int64_t pos);
++
++void av_parser_close(AVCodecParserContext *s);
++
++int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
++ const AVSubtitle *sub);
++
++unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt);
++
++enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list,
++ enum AVPixelFormat src_pix_fmt,
++ int has_alpha, int *loss_ptr);
++
++enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
++
++void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
++
++int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size);
++int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count);
++
++int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
++ enum AVSampleFormat sample_fmt, const uint8_t *buf,
++ int buf_size, int align);
++
++void avcodec_flush_buffers(AVCodecContext *avctx);
++
++int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes);
++
++void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);
++
++void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size);
++
++int avcodec_is_open(AVCodecContext *s);
++
++#define AVFORMAT_AVFORMAT_H
++
++#define AVFORMAT_AVIO_H
++
++#define AVFORMAT_VERSION_MAJOR_H
++
++#define LIBAVFORMAT_VERSION_MAJOR 60
++
++#define FF_API_COMPUTE_PKT_FIELDS2 (LIBAVFORMAT_VERSION_MAJOR < 61)
++#define FF_API_GET_END_PTS (LIBAVFORMAT_VERSION_MAJOR < 61)
++#define FF_API_AVIODIRCONTEXT (LIBAVFORMAT_VERSION_MAJOR < 61)
++#define FF_API_AVFORMAT_IO_CLOSE (LIBAVFORMAT_VERSION_MAJOR < 61)
++
++#define FF_API_R_FRAME_RATE 1
++
++#define AVIO_SEEKABLE_NORMAL (1 << 0)
++
++#define AVIO_SEEKABLE_TIME (1 << 1)
++
++typedef struct AVIOInterruptCB {
++ int (*callback)(void*);
++ void *opaque;
++} AVIOInterruptCB;
++
++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,
++};
++
++typedef struct AVIODirEntry {
++ char *name;
++ int type;
++ int utf8;
++
++ int64_t size;
++ int64_t modification_timestamp;
++
++ int64_t access_timestamp;
++
++ int64_t status_change_timestamp;
++
++ int64_t user_id;
++ int64_t group_id;
++ int64_t filemode;
++} AVIODirEntry;
++
++typedef struct AVIODirContext {
++ struct URLContext *url_context;
++} AVIODirContext;
++
++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,
++};
++
++typedef struct AVIOContext {
++
++ const AVClass *av_class;
++
++ unsigned char *buffer;
++ int buffer_size;
++ unsigned char *buf_ptr;
++ unsigned char *buf_end;
++
++ void *opaque;
++
++ int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
++ int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
++ int64_t (*seek)(void *opaque, int64_t offset, int whence);
++ int64_t pos;
++ int eof_reached;
++ int error;
++ int write_flag;
++ int max_packet_size;
++ int min_packet_size;
++
++ unsigned long checksum;
++ unsigned char *checksum_ptr;
++ unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
++
++ int (*read_pause)(void *opaque, int pause);
++
++ int64_t (*read_seek)(void *opaque, int stream_index,
++ int64_t timestamp, int flags);
++
++ int seekable;
++
++ int direct;
++
++ const char *protocol_whitelist;
++
++ const char *protocol_blacklist;
++
++ int (*write_data_type)(void *opaque, uint8_t *buf, int buf_size,
++ enum AVIODataMarkerType type, int64_t time);
++
++ int ignore_boundary_point;
++
++ unsigned char *buf_ptr_max;
++
++ int64_t bytes_read;
++
++ int64_t bytes_written;
++} AVIOContext;
++
++const char *avio_find_protocol_name(const char *url);
++
++int avio_check(const char *url, int flags);
++
++int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options);
++
++int avio_read_dir(AVIODirContext *s, AVIODirEntry **next);
++
++int avio_close_dir(AVIODirContext **s);
++
++void avio_free_directory_entry(AVIODirEntry **entry);
++
++AVIOContext *avio_alloc_context(
++ unsigned char *buffer,
++ int buffer_size,
++ int write_flag,
++ void *opaque,
++ int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
++ int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
++ int64_t (*seek)(void *opaque, int64_t offset, int whence));
++
++void avio_context_free(AVIOContext **s);
++
++void avio_w8(AVIOContext *s, int b);
++void avio_write(AVIOContext *s, const unsigned char *buf, int size);
++void avio_wl64(AVIOContext *s, uint64_t val);
++void avio_wb64(AVIOContext *s, uint64_t val);
++void avio_wl32(AVIOContext *s, unsigned int val);
++void avio_wb32(AVIOContext *s, unsigned int val);
++void avio_wl24(AVIOContext *s, unsigned int val);
++void avio_wb24(AVIOContext *s, unsigned int val);
++void avio_wl16(AVIOContext *s, unsigned int val);
++void avio_wb16(AVIOContext *s, unsigned int val);
++
++int avio_put_str(AVIOContext *s, const char *str);
++
++int avio_put_str16le(AVIOContext *s, const char *str);
++
++int avio_put_str16be(AVIOContext *s, const char *str);
++
++void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type);
++
++#define AVSEEK_SIZE 0x10000
++
++#define AVSEEK_FORCE 0x20000
++
++int64_t avio_seek(AVIOContext *s, int64_t offset, int whence);
++
++int64_t avio_skip(AVIOContext *s, int64_t offset);
++
++static av_always_inline int64_t avio_tell(AVIOContext *s)
++{
++ return avio_seek(s, 0, SEEK_CUR);
++}
++
++int64_t avio_size(AVIOContext *s);
++
++int avio_feof(AVIOContext *s);
++
++int avio_vprintf(AVIOContext *s, const char *fmt, va_list ap);
++
++int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
++
++void avio_print_string_array(AVIOContext *s, const char *strings[]);
++
++#define avio_print(s, ...) \
++ avio_print_string_array(s, (const char*[]){__VA_ARGS__, NULL})
++
++void avio_flush(AVIOContext *s);
++
++int avio_read(AVIOContext *s, unsigned char *buf, int size);
++
++int avio_read_partial(AVIOContext *s, unsigned char *buf, int size);
++
++int avio_r8 (AVIOContext *s);
++unsigned int avio_rl16(AVIOContext *s);
++unsigned int avio_rl24(AVIOContext *s);
++unsigned int avio_rl32(AVIOContext *s);
++uint64_t avio_rl64(AVIOContext *s);
++unsigned int avio_rb16(AVIOContext *s);
++unsigned int avio_rb24(AVIOContext *s);
++unsigned int avio_rb32(AVIOContext *s);
++uint64_t avio_rb64(AVIOContext *s);
++
++int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen);
++
++int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen);
++int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
++
++#define AVIO_FLAG_READ 1
++#define AVIO_FLAG_WRITE 2
++#define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE)
++
++#define AVIO_FLAG_NONBLOCK 8
++
++#define AVIO_FLAG_DIRECT 0x8000
++
++int avio_open(AVIOContext **s, const char *url, int flags);
++
++int avio_open2(AVIOContext **s, const char *url, int flags,
++ const AVIOInterruptCB *int_cb, AVDictionary **options);
++
++int avio_close(AVIOContext *s);
++
++int avio_closep(AVIOContext **s);
++
++int avio_open_dyn_buf(AVIOContext **s);
++
++int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
++
++int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
++
++const char *avio_enum_protocols(void **opaque, int output);
++
++const AVClass *avio_protocol_get_class(const char *name);
++
++int avio_pause(AVIOContext *h, int pause);
++
++int64_t avio_seek_time(AVIOContext *h, int stream_index,
++ int64_t timestamp, int flags);
++
++struct AVBPrint;
++
++int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size);
++
++int avio_accept(AVIOContext *s, AVIOContext **c);
++
++int avio_handshake(AVIOContext *c);
++
++#define AVFORMAT_VERSION_H
++
++#define LIBAVFORMAT_VERSION_MINOR 3
++#define LIBAVFORMAT_VERSION_MICRO 100
++
++#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
++ LIBAVFORMAT_VERSION_MINOR, \
++ LIBAVFORMAT_VERSION_MICRO)
++#define LIBAVFORMAT_VERSION AV_VERSION(LIBAVFORMAT_VERSION_MAJOR, \
++ LIBAVFORMAT_VERSION_MINOR, \
++ LIBAVFORMAT_VERSION_MICRO)
++#define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT
++
++#define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
++
++struct AVFormatContext;
++
++struct AVDeviceInfoList;
++
++int av_get_packet(AVIOContext *s, AVPacket *pkt, int size);
++
++int av_append_packet(AVIOContext *s, AVPacket *pkt, int size);
++
++struct AVCodecTag;
++
++typedef struct AVProbeData {
++ const char *filename;
++ unsigned char *buf;
++ int buf_size;
++ const char *mime_type;
++} AVProbeData;
++
++#define AVPROBE_SCORE_RETRY (AVPROBE_SCORE_MAX/4)
++#define AVPROBE_SCORE_STREAM_RETRY (AVPROBE_SCORE_MAX/4-1)
++
++#define AVPROBE_SCORE_EXTENSION 50
++#define AVPROBE_SCORE_MIME 75
++#define AVPROBE_SCORE_MAX 100
++
++#define AVPROBE_PADDING_SIZE 32
++
++#define AVFMT_NOFILE 0x0001
++#define AVFMT_NEEDNUMBER 0x0002
++
++#define AVFMT_EXPERIMENTAL 0x0004
++#define AVFMT_SHOW_IDS 0x0008
++#define AVFMT_GLOBALHEADER 0x0040
++#define AVFMT_NOTIMESTAMPS 0x0080
++#define AVFMT_GENERIC_INDEX 0x0100
++#define AVFMT_TS_DISCONT 0x0200
++#define AVFMT_VARIABLE_FPS 0x0400
++#define AVFMT_NODIMENSIONS 0x0800
++#define AVFMT_NOSTREAMS 0x1000
++#define AVFMT_NOBINSEARCH 0x2000
++#define AVFMT_NOGENSEARCH 0x4000
++#define AVFMT_NO_BYTE_SEEK 0x8000
++#define AVFMT_ALLOW_FLUSH 0x10000
++#define AVFMT_TS_NONSTRICT 0x20000
++
++#define AVFMT_TS_NEGATIVE 0x40000
++
++#define AVFMT_SEEK_TO_PTS 0x4000000
++
++typedef struct AVOutputFormat {
++ const char *name;
++
++ const char *long_name;
++ const char *mime_type;
++ const char *extensions;
++
++ enum AVCodecID audio_codec;
++ enum AVCodecID video_codec;
++ enum AVCodecID subtitle_codec;
++
++ int flags;
++
++ const struct AVCodecTag * const *codec_tag;
++
++ const AVClass *priv_class;
++} AVOutputFormat;
++
++typedef struct AVInputFormat {
++
++ const char *name;
++
++ const char *long_name;
++
++ int flags;
++
++ const char *extensions;
++
++ const struct AVCodecTag * const *codec_tag;
++
++ const AVClass *priv_class;
++
++ const char *mime_type;
++
++ int raw_codec_id;
++
++ int priv_data_size;
++
++ int flags_internal;
++
++ int (*read_probe)(const AVProbeData *);
++
++ int (*read_header)(struct AVFormatContext *);
++
++ int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);
++
++ int (*read_close)(struct AVFormatContext *);
++
++ int (*read_seek)(struct AVFormatContext *,
++ int stream_index, int64_t timestamp, int flags);
++
++ int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index,
++ int64_t *pos, int64_t pos_limit);
++
++ int (*read_play)(struct AVFormatContext *);
++
++ int (*read_pause)(struct AVFormatContext *);
++
++ int (*read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
++
++ int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
++
++} AVInputFormat;
++
++enum AVStreamParseType {
++ AVSTREAM_PARSE_NONE,
++ AVSTREAM_PARSE_FULL,
++ AVSTREAM_PARSE_HEADERS,
++ AVSTREAM_PARSE_TIMESTAMPS,
++ AVSTREAM_PARSE_FULL_ONCE,
++ AVSTREAM_PARSE_FULL_RAW,
++
++};
++
++typedef struct AVIndexEntry {
++ int64_t pos;
++ int64_t timestamp;
++
++#define AVINDEX_KEYFRAME 0x0001
++#define AVINDEX_DISCARD_FRAME 0x0002
++
++ int flags:2;
++ int size:30;
++ int min_distance;
++} AVIndexEntry;
++
++#define AV_DISPOSITION_DEFAULT (1 << 0)
++
++#define AV_DISPOSITION_DUB (1 << 1)
++
++#define AV_DISPOSITION_ORIGINAL (1 << 2)
++
++#define AV_DISPOSITION_COMMENT (1 << 3)
++
++#define AV_DISPOSITION_LYRICS (1 << 4)
++
++#define AV_DISPOSITION_KARAOKE (1 << 5)
++
++#define AV_DISPOSITION_FORCED (1 << 6)
++
++#define AV_DISPOSITION_HEARING_IMPAIRED (1 << 7)
++
++#define AV_DISPOSITION_VISUAL_IMPAIRED (1 << 8)
++
++#define AV_DISPOSITION_CLEAN_EFFECTS (1 << 9)
++
++#define AV_DISPOSITION_ATTACHED_PIC (1 << 10)
++
++#define AV_DISPOSITION_TIMED_THUMBNAILS (1 << 11)
++
++#define AV_DISPOSITION_NON_DIEGETIC (1 << 12)
++
++#define AV_DISPOSITION_CAPTIONS (1 << 16)
++
++#define AV_DISPOSITION_DESCRIPTIONS (1 << 17)
++
++#define AV_DISPOSITION_METADATA (1 << 18)
++
++#define AV_DISPOSITION_DEPENDENT (1 << 19)
++
++#define AV_DISPOSITION_STILL_IMAGE (1 << 20)
++
++int av_disposition_from_string(const char *disp);
++
++const char *av_disposition_to_string(int disposition);
++
++#define AV_PTS_WRAP_IGNORE 0
++#define AV_PTS_WRAP_ADD_OFFSET 1
++#define AV_PTS_WRAP_SUB_OFFSET -1
++
++typedef struct AVStream {
++
++ const AVClass *av_class;
++
++ int index;
++
++ int id;
++
++ AVCodecParameters *codecpar;
++
++ void *priv_data;
++
++ AVRational time_base;
++
++ int64_t start_time;
++
++ int64_t duration;
++
++ int64_t nb_frames;
++
++ int disposition;
++
++ enum AVDiscard discard;
++
++ AVRational sample_aspect_ratio;
++
++ AVDictionary *metadata;
++
++ AVRational avg_frame_rate;
++
++ AVPacket attached_pic;
++
++ AVPacketSideData *side_data;
++
++ int nb_side_data;
++
++ int event_flags;
++
++#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED 0x0001
++
++#define AVSTREAM_EVENT_FLAG_NEW_PACKETS (1 << 1)
++
++ AVRational r_frame_rate;
++
++ int pts_wrap_bits;
++} AVStream;
++
++struct AVCodecParserContext *av_stream_get_parser(const AVStream *s);
++
++attribute_deprecated
++int64_t av_stream_get_end_pts(const AVStream *st);
++
++#define AV_PROGRAM_RUNNING 1
++
++typedef struct AVProgram {
++ int id;
++ int flags;
++ enum AVDiscard discard;
++ unsigned int *stream_index;
++ unsigned int nb_stream_indexes;
++ AVDictionary *metadata;
++
++ int program_num;
++ int pmt_pid;
++ int pcr_pid;
++ int pmt_version;
++
++ int64_t start_time;
++ int64_t end_time;
++
++ int64_t pts_wrap_reference;
++ int pts_wrap_behavior;
++} AVProgram;
++
++#define AVFMTCTX_NOHEADER 0x0001
++
++#define AVFMTCTX_UNSEEKABLE 0x0002
++
++typedef struct AVChapter {
++ int64_t id;
++ AVRational time_base;
++ int64_t start, end;
++ AVDictionary *metadata;
++} AVChapter;
++
++typedef int (*av_format_control_message)(struct AVFormatContext *s, int type,
++ void *data, size_t data_size);
++
++typedef int (*AVOpenCallback)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
++ const AVIOInterruptCB *int_cb, AVDictionary **options);
++
++enum AVDurationEstimationMethod {
++ AVFMT_DURATION_FROM_PTS,
++ AVFMT_DURATION_FROM_STREAM,
++ AVFMT_DURATION_FROM_BITRATE
++};
++
++typedef struct AVFormatContext {
++
++ const AVClass *av_class;
++
++ const struct AVInputFormat *iformat;
++
++ const struct AVOutputFormat *oformat;
++
++ void *priv_data;
++
++ AVIOContext *pb;
++
++ int ctx_flags;
++
++ unsigned int nb_streams;
++
++ AVStream **streams;
++
++ char *url;
++
++ int64_t start_time;
++
++ int64_t duration;
++
++ int64_t bit_rate;
++
++ unsigned int packet_size;
++ int max_delay;
++
++ int flags;
++#define AVFMT_FLAG_GENPTS 0x0001
++#define AVFMT_FLAG_IGNIDX 0x0002
++#define AVFMT_FLAG_NONBLOCK 0x0004
++#define AVFMT_FLAG_IGNDTS 0x0008
++#define AVFMT_FLAG_NOFILLIN 0x0010
++#define AVFMT_FLAG_NOPARSE 0x0020
++#define AVFMT_FLAG_NOBUFFER 0x0040
++#define AVFMT_FLAG_CUSTOM_IO 0x0080
++#define AVFMT_FLAG_DISCARD_CORRUPT 0x0100
++#define AVFMT_FLAG_FLUSH_PACKETS 0x0200
++
++#define AVFMT_FLAG_BITEXACT 0x0400
++#define AVFMT_FLAG_SORT_DTS 0x10000
++#define AVFMT_FLAG_FAST_SEEK 0x80000
++#define AVFMT_FLAG_SHORTEST 0x100000
++#define AVFMT_FLAG_AUTO_BSF 0x200000
++
++ int64_t probesize;
++
++ int64_t max_analyze_duration;
++
++ const uint8_t *key;
++ int keylen;
++
++ unsigned int nb_programs;
++ AVProgram **programs;
++
++ enum AVCodecID video_codec_id;
++
++ enum AVCodecID audio_codec_id;
++
++ enum AVCodecID subtitle_codec_id;
++
++ unsigned int max_index_size;
++
++ unsigned int max_picture_buffer;
++
++ unsigned int nb_chapters;
++ AVChapter **chapters;
++
++ AVDictionary *metadata;
++
++ int64_t start_time_realtime;
++
++ int fps_probe_size;
++
++ int error_recognition;
++
++ AVIOInterruptCB interrupt_callback;
++
++ int debug;
++#define FF_FDEBUG_TS 0x0001
++
++ int64_t max_interleave_delta;
++
++ int strict_std_compliance;
++
++ int event_flags;
++
++#define AVFMT_EVENT_FLAG_METADATA_UPDATED 0x0001
++
++ int max_ts_probe;
++
++ int avoid_negative_ts;
++#define AVFMT_AVOID_NEG_TS_AUTO -1
++#define AVFMT_AVOID_NEG_TS_DISABLED 0
++#define AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE 1
++#define AVFMT_AVOID_NEG_TS_MAKE_ZERO 2
++
++ int ts_id;
++
++ int audio_preload;
++
++ int max_chunk_duration;
++
++ int max_chunk_size;
++
++ int use_wallclock_as_timestamps;
++
++ int avio_flags;
++
++ enum AVDurationEstimationMethod duration_estimation_method;
++
++ int64_t skip_initial_bytes;
++
++ unsigned int correct_ts_overflow;
++
++ int seek2any;
++
++ int flush_packets;
++
++ int probe_score;
++
++ int format_probesize;
++
++ char *codec_whitelist;
++
++ char *format_whitelist;
++
++ int io_repositioned;
++
++ const AVCodec *video_codec;
++
++ const AVCodec *audio_codec;
++
++ const AVCodec *subtitle_codec;
++
++ const AVCodec *data_codec;
++
++ int metadata_header_padding;
++
++ void *opaque;
++
++ av_format_control_message control_message_cb;
++
++ int64_t output_ts_offset;
++
++ uint8_t *dump_separator;
++
++ enum AVCodecID data_codec_id;
++
++ char *protocol_whitelist;
++
++ int (*io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url,
++ int flags, AVDictionary **options);
++
++ attribute_deprecated
++ void (*io_close)(struct AVFormatContext *s, AVIOContext *pb);
++
++ char *protocol_blacklist;
++
++ int max_streams;
++
++ int skip_estimate_duration_from_pts;
++
++ int max_probe_packets;
++
++ int (*io_close2)(struct AVFormatContext *s, AVIOContext *pb);
++} AVFormatContext;
++
++void av_format_inject_global_side_data(AVFormatContext *s);
++
++enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method(const AVFormatContext* ctx);
++
++unsigned avformat_version(void);
++
++const char *avformat_configuration(void);
++
++const char *avformat_license(void);
++
++int avformat_network_init(void);
++
++int avformat_network_deinit(void);
++
++const AVOutputFormat *av_muxer_iterate(void **opaque);
++
++const AVInputFormat *av_demuxer_iterate(void **opaque);
++
++AVFormatContext *avformat_alloc_context(void);
++
++void avformat_free_context(AVFormatContext *s);
++
++const AVClass *avformat_get_class(void);
++
++const AVClass *av_stream_get_class(void);
++
++AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c);
++
++int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
++ uint8_t *data, size_t size);
++
++uint8_t *av_stream_new_side_data(AVStream *stream,
++ enum AVPacketSideDataType type, size_t size);
++
++uint8_t *av_stream_get_side_data(const AVStream *stream,
++ enum AVPacketSideDataType type, size_t *size);
++
++AVProgram *av_new_program(AVFormatContext *s, int id);
++
++int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat,
++ const char *format_name, const char *filename);
++
++const AVInputFormat *av_find_input_format(const char *short_name);
++
++const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened);
++
++const AVInputFormat *av_probe_input_format2(const AVProbeData *pd,
++ int is_opened, int *score_max);
++
++const AVInputFormat *av_probe_input_format3(const AVProbeData *pd,
++ int is_opened, int *score_ret);
++
++int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt,
++ const char *url, void *logctx,
++ unsigned int offset, unsigned int max_probe_size);
++
++int av_probe_input_buffer(AVIOContext *pb, const AVInputFormat **fmt,
++ const char *url, void *logctx,
++ unsigned int offset, unsigned int max_probe_size);
++
++int avformat_open_input(AVFormatContext **ps, const char *url,
++ const AVInputFormat *fmt, AVDictionary **options);
++
++int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
++
++AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s);
++
++void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx);
++
++int av_find_best_stream(AVFormatContext *ic,
++ enum AVMediaType type,
++ int wanted_stream_nb,
++ int related_stream,
++ const AVCodec **decoder_ret,
++ int flags);
++
++int av_read_frame(AVFormatContext *s, AVPacket *pkt);
++
++int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp,
++ int flags);
++
++int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
++
++int avformat_flush(AVFormatContext *s);
++
++int av_read_play(AVFormatContext *s);
++
++int av_read_pause(AVFormatContext *s);
++
++void avformat_close_input(AVFormatContext **s);
++
++#define AVSEEK_FLAG_BACKWARD 1
++#define AVSEEK_FLAG_BYTE 2
++#define AVSEEK_FLAG_ANY 4
++#define AVSEEK_FLAG_FRAME 8
++
++#define AVSTREAM_INIT_IN_WRITE_HEADER 0
++#define AVSTREAM_INIT_IN_INIT_OUTPUT 1
++
++av_warn_unused_result
++int avformat_write_header(AVFormatContext *s, AVDictionary **options);
++
++av_warn_unused_result
++int avformat_init_output(AVFormatContext *s, AVDictionary **options);
++
++int av_write_frame(AVFormatContext *s, AVPacket *pkt);
++
++int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);
++
++int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
++ AVFrame *frame);
++
++int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index,
++ AVFrame *frame);
++
++int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index);
++
++int av_write_trailer(AVFormatContext *s);
++
++const AVOutputFormat *av_guess_format(const char *short_name,
++ const char *filename,
++ const char *mime_type);
++
++enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
++ const char *filename, const char *mime_type,
++ enum AVMediaType type);
++
++int av_get_output_timestamp(struct AVFormatContext *s, int stream,
++ int64_t *dts, int64_t *wall);
++
++void av_hex_dump(FILE *f, const uint8_t *buf, int size);
++
++void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size);
++
++void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st);
++
++void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
++ const AVStream *st);
++
++enum AVCodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);
++
++unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum AVCodecID id);
++
++int av_codec_get_tag2(const struct AVCodecTag * const *tags, enum AVCodecID id,
++ unsigned int *tag);
++
++int av_find_default_stream_index(AVFormatContext *s);
++
++int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
++
++int avformat_index_get_entries_count(const AVStream *st);
++
++const AVIndexEntry *avformat_index_get_entry(AVStream *st, int idx);
++
++const AVIndexEntry *avformat_index_get_entry_from_timestamp(AVStream *st,
++ int64_t wanted_timestamp,
++ int flags);
++
++int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
++ int size, int distance, int flags);
++
++void av_url_split(char *proto, int proto_size,
++ char *authorization, int authorization_size,
++ char *hostname, int hostname_size,
++ int *port_ptr,
++ char *path, int path_size,
++ const char *url);
++
++void av_dump_format(AVFormatContext *ic,
++ int index,
++ const char *url,
++ int is_output);
++
++#define AV_FRAME_FILENAME_FLAGS_MULTIPLE 1
++
++int av_get_frame_filename2(char *buf, int buf_size,
++ const char *path, int number, int flags);
++
++int av_get_frame_filename(char *buf, int buf_size,
++ const char *path, int number);
++
++int av_filename_number_test(const char *filename);
++
++int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size);
++
++int av_match_ext(const char *filename, const char *extensions);
++
++int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
++ int std_compliance);
++
++const struct AVCodecTag *avformat_get_riff_video_tags(void);
++
++const struct AVCodecTag *avformat_get_riff_audio_tags(void);
++
++const struct AVCodecTag *avformat_get_mov_video_tags(void);
++
++const struct AVCodecTag *avformat_get_mov_audio_tags(void);
++
++AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame);
++
++AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame);
++
++int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
++ const char *spec);
++
++int avformat_queue_attached_pictures(AVFormatContext *s);
++
++enum AVTimebaseSource {
++ AVFMT_TBCF_AUTO = -1,
++ AVFMT_TBCF_DECODER,
++ AVFMT_TBCF_DEMUXER,
++ AVFMT_TBCF_R_FRAMERATE,
++};
++
++int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
++ AVStream *ost, const AVStream *ist,
++ enum AVTimebaseSource copy_tb);
++
++AVRational av_stream_get_codec_timebase(const AVStream *st);
++
++#define AVUTIL_FIFO_H
++
++typedef struct AVFifo AVFifo;
++
++typedef int AVFifoCB(void *opaque, void *buf, size_t *nb_elems);
++
++#define AV_FIFO_FLAG_AUTO_GROW (1 << 0)
++
++AVFifo *av_fifo_alloc2(size_t elems, size_t elem_size,
++ unsigned int flags);
++
++size_t av_fifo_elem_size(const AVFifo *f);
++
++void av_fifo_auto_grow_limit(AVFifo *f, size_t max_elems);
++
++size_t av_fifo_can_read(const AVFifo *f);
++
++size_t av_fifo_can_write(const AVFifo *f);
++
++int av_fifo_grow2(AVFifo *f, size_t inc);
++
++int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems);
++
++int av_fifo_write_from_cb(AVFifo *f, AVFifoCB read_cb,
++ void *opaque, size_t *nb_elems);
++
++int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems);
++
++int av_fifo_read_to_cb(AVFifo *f, AVFifoCB write_cb,
++ void *opaque, size_t *nb_elems);
++
++int av_fifo_peek(AVFifo *f, void *buf, size_t nb_elems, size_t offset);
++
++int av_fifo_peek_to_cb(AVFifo *f, AVFifoCB write_cb, void *opaque,
++ size_t *nb_elems, size_t offset);
++
++void av_fifo_drain2(AVFifo *f, size_t size);
++
++void av_fifo_reset2(AVFifo *f);
++
++void av_fifo_freep2(AVFifo **f);
++
++typedef struct AVFifoBuffer {
++ uint8_t *buffer;
++ uint8_t *rptr, *wptr, *end;
++ uint32_t rndx, wndx;
++} AVFifoBuffer;
++
++attribute_deprecated
++AVFifoBuffer *av_fifo_alloc(unsigned int size);
++
++attribute_deprecated
++AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size);
++
++attribute_deprecated
++void av_fifo_free(AVFifoBuffer *f);
++
++attribute_deprecated
++void av_fifo_freep(AVFifoBuffer **f);
++
++attribute_deprecated
++void av_fifo_reset(AVFifoBuffer *f);
++
++attribute_deprecated
++int av_fifo_size(const AVFifoBuffer *f);
++
++attribute_deprecated
++int av_fifo_space(const AVFifoBuffer *f);
++
++attribute_deprecated
++int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_size, void (*func)(void*, void*, int));
++
++attribute_deprecated
++int av_fifo_generic_peek(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
++
++attribute_deprecated
++int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
++
++attribute_deprecated
++int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int));
++
++attribute_deprecated
++int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
++
++attribute_deprecated
++int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space);
++
++attribute_deprecated
++void av_fifo_drain(AVFifoBuffer *f, int size);
++
++attribute_deprecated
++static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
++{
++ uint8_t *ptr = f->rptr + offs;
++ if (ptr >= f->end)
++ ptr = f->buffer + (ptr - f->end);
++ else if (ptr < f->buffer)
++ ptr = f->end - (f->buffer - ptr);
++ return ptr;
++}
++
+
+From 4e47807dc905986ae785a3ca191ddbe6135e5070 Mon Sep 17 00:00:00 2001
+From: Dmitry Vedenko <dmitry(a)crsib.me>
+Date: Thu, 16 Mar 2023 17:43:31 +0300
+Subject: [PATCH 2/3] Do not use FF_API_XVMC to guard against the
+ AV_CODEC_ID_MPEG2VIDEO_XVMC
+
+---
+ libraries/lib-ffmpeg-support/impl/AVCodecIDLookup.inl | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/libraries/lib-ffmpeg-support/impl/AVCodecIDLookup.inl b/libraries/lib-ffmpeg-support/impl/AVCodecIDLookup.inl
+index 339b0bf906b..8a77ff849fe 100644
+--- a/libraries/lib-ffmpeg-support/impl/AVCodecIDLookup.inl
++++ b/libraries/lib-ffmpeg-support/impl/AVCodecIDLookup.inl
+@@ -17,7 +17,7 @@ AVCodecIDFwd AVCodecIDLookup[AUDACITY_AV_CODEC_ID_LAST] = {
+
+ AV_CODEC_ID_MPEG1VIDEO,
+ AV_CODEC_ID_MPEG2VIDEO,
+-#if FF_API_XVMC
++#if LIBAVUTIL_VERSION_MAJOR < 56
+ AV_CODEC_ID_MPEG2VIDEO_XVMC,
+ #else
+ AV_CODEC_ID_NONE,
+
+From 7328195a6989414f0c8bb2ba7b2ff2b55ce01976 Mon Sep 17 00:00:00 2001
+From: Dmitry Vedenko <dmitry(a)crsib.me>
+Date: Thu, 16 Mar 2023 17:44:39 +0300
+Subject: [PATCH 3/3] Adds FFmpeg 6.0 support
+
+---
+ libraries/lib-ffmpeg-support/CMakeLists.txt | 7 +++
+ .../impl/avcodec/60/AVCodecIDLookup.cpp | 37 ++++++++++++++
+ .../impl/avcodec/60/AVCodecImpl.cpp | 46 +++++++++++++++++
+ .../impl/avformat/60/AVFormatImpl.cpp | 50 +++++++++++++++++++
+ .../impl/avutil/58/AVUtilImpl.cpp | 39 +++++++++++++++
+ .../impl/avutil/58/avconfig.h | 8 +++
+ 6 files changed, 187 insertions(+)
+ create mode 100644 libraries/lib-ffmpeg-support/impl/avcodec/60/AVCodecIDLookup.cpp
+ create mode 100644 libraries/lib-ffmpeg-support/impl/avcodec/60/AVCodecImpl.cpp
+ create mode 100644 libraries/lib-ffmpeg-support/impl/avformat/60/AVFormatImpl.cpp
+ create mode 100644 libraries/lib-ffmpeg-support/impl/avutil/58/AVUtilImpl.cpp
+ create mode 100644 libraries/lib-ffmpeg-support/impl/avutil/58/avconfig.h
+
+diff --git a/libraries/lib-ffmpeg-support/CMakeLists.txt b/libraries/lib-ffmpeg-support/CMakeLists.txt
+index aea8f11ed42..a6c40230216 100644
+--- a/libraries/lib-ffmpeg-support/CMakeLists.txt
++++ b/libraries/lib-ffmpeg-support/CMakeLists.txt
+@@ -70,6 +70,13 @@ if (${_OPT}use_ffmpeg)
+ impl/avformat/59/AVFormatImpl.cpp
+ impl/avutil/57/AVUtilImpl.cpp
+
++ impl/ffmpeg-6.0.0-single-header.h
++ impl/avutil/58/avconfig.h
++ impl/avcodec/60/AVCodecIDLookup.cpp
++ impl/avcodec/60/AVCodecImpl.cpp
++ impl/avformat/60/AVFormatImpl.cpp
++ impl/avutil/58/AVUtilImpl.cpp
++
+ # Loaders
+ impl/avcodec/AVCodecFunctionsLoader.cpp
+ impl/avcodec/AVCodecFunctionsLoader.h
+diff --git a/libraries/lib-ffmpeg-support/impl/avcodec/60/AVCodecIDLookup.cpp b/libraries/lib-ffmpeg-support/impl/avcodec/60/AVCodecIDLookup.cpp
+new file mode 100644
+index 00000000000..e626ad74c55
+--- /dev/null
++++ b/libraries/lib-ffmpeg-support/impl/avcodec/60/AVCodecIDLookup.cpp
+@@ -0,0 +1,37 @@
++extern "C"
++{
++#include "../../avutil/58/avconfig.h"
++#include "../../ffmpeg-6.0.0-single-header.h"
++}
++
++#include <algorithm>
++
++#include "AVCodecID.h"
++
++#include "../../FFmpegAPIResolver.h"
++
++#define AV_CODEC_ID_ESCAPE130_DEPRECATED AV_CODEC_ID_ESCAPE130
++#define AV_CODEC_ID_G2M_DEPRECATED AV_CODEC_ID_G2M
++#define AV_CODEC_ID_WEBP_DEPRECATED AV_CODEC_ID_WEBP
++#define AV_CODEC_ID_HEVC_DEPRECATED AV_CODEC_ID_HEVC
++#define AV_CODEC_ID_PCM_S24LE_PLANAR_DEPRECATED AV_CODEC_ID_PCM_S24LE_PLANAR
++#define AV_CODEC_ID_PCM_S32LE_PLANAR_DEPRECATED AV_CODEC_ID_PCM_S32LE_PLANAR
++#define AV_CODEC_ID_OPUS_DEPRECATED AV_CODEC_ID_OPUS
++#define AV_CODEC_ID_TAK_DEPRECATED AV_CODEC_ID_TAK
++
++#define AV_CODEC_ID_VIMA AV_CODEC_ID_ADPCM_VIMA
++
++namespace avcodec_60
++{
++#include "../../AVCodecIDLookup.inl"
++
++const bool registered = ([]() {
++ FFmpegAPIResolver::Get().AddAVCodecIDResolver(60, {
++ &GetAVCodeID,
++ &GetAudacityCodecID
++ });
++
++ return true;
++})();
++
++}
+diff --git a/libraries/lib-ffmpeg-support/impl/avcodec/60/AVCodecImpl.cpp b/libraries/lib-ffmpeg-support/impl/avcodec/60/AVCodecImpl.cpp
+new file mode 100644
+index 00000000000..92e85612bff
+--- /dev/null
++++ b/libraries/lib-ffmpeg-support/impl/avcodec/60/AVCodecImpl.cpp
+@@ -0,0 +1,46 @@
++extern "C"
++{
++#include "../../avutil/58/avconfig.h"
++#include "../../ffmpeg-6.0.0-single-header.h"
++}
++
++#include <cstring>
++#include <numeric>
++
++#include "float_cast.h"
++
++#include "FFmpegFunctions.h"
++
++#include "wrappers/AVCodecContextWrapper.h"
++#include "wrappers/AVCodecWrapper.h"
++#include "wrappers/AVPacketWrapper.h"
++
++#include "../../FFmpegAPIResolver.h"
++
++namespace avcodec_60
++{
++#include "../AVCodecContextWrapperImpl.inl"
++#include "../AVCodecWrapperImpl.inl"
++#include "../AVPacketWrapperImpl.inl"
++
++const bool registered = ([]() {
++ FFmpegAPIResolver::Get().AddAVCodecFactories(60, {
++ &CreateAVCodecContextWrapper,
++ &CreateAVCodecContextWrapperFromCodec,
++ &CreateAVCodecWrapper,
++ &CreateAVPacketWrapper,
++ });
++
++ return true;
++})();
++}
++
++#include "FFmpegTypes.h"
++static_assert(
++ AV_CODEC_FLAG_GLOBAL_HEADER == AUDACITY_AV_CODEC_FLAG_GLOBAL_HEADER
++ && AV_CODEC_CAP_SMALL_LAST_FRAME == AUDACITY_AV_CODEC_CAP_SMALL_LAST_FRAME
++ && AV_CODEC_FLAG_QSCALE == AUDACITY_AV_CODEC_FLAG_QSCALE
++,
++ "FFmpeg constants don't match"
++);
++
+diff --git a/libraries/lib-ffmpeg-support/impl/avformat/60/AVFormatImpl.cpp b/libraries/lib-ffmpeg-support/impl/avformat/60/AVFormatImpl.cpp
+new file mode 100644
+index 00000000000..8384a5e72cf
+--- /dev/null
++++ b/libraries/lib-ffmpeg-support/impl/avformat/60/AVFormatImpl.cpp
+@@ -0,0 +1,50 @@
++/**********************************************************************
++
++ Audacity: A Digital Audio Editor
++
++ AVFormatImpl.cpp
++
++ Dmitry Vedenko
++
++**********************************************************************/
++
++extern "C"
++{
++#include "../../avutil/58/avconfig.h"
++#include "../../ffmpeg-6.0.0-single-header.h"
++}
++
++#include <cstring>
++
++#include "FFmpegFunctions.h"
++
++#include "wrappers/AVFormatContextWrapper.h"
++#include "wrappers/AVInputFormatWrapper.h"
++#include "wrappers/AVIOContextWrapper.h"
++#include "wrappers/AVOutputFormatWrapper.h"
++#include "wrappers/AVStreamWrapper.h"
++
++#include "wrappers/AVCodecWrapper.h"
++
++#include "../../FFmpegAPIResolver.h"
++
++namespace avformat_60
++{
++#include "../AVFormatContextWrapperImpl.inl"
++#include "../AVInputFormatWrapperImpl.inl"
++#include "../AVIOContextWrapperImpl.inl"
++#include "../AVOutputFormatWrapperImpl.inl"
++#include "../AVStreamWrapperImpl.inl"
++
++const bool registered = ([]() {
++ FFmpegAPIResolver::Get().AddAVFormatFactories(60, {
++ &CreateAVFormatContextWrapper,
++ &CreateAVInputFormatWrapper,
++ &CreateAVIOContextWrapper,
++ &CreateAVOutputFormatWrapper,
++ &CreateAVStreamWrapper,
++ });
++
++ return true;
++})();
++}
+diff --git a/libraries/lib-ffmpeg-support/impl/avutil/58/AVUtilImpl.cpp b/libraries/lib-ffmpeg-support/impl/avutil/58/AVUtilImpl.cpp
+new file mode 100644
+index 00000000000..12341ca6b2f
+--- /dev/null
++++ b/libraries/lib-ffmpeg-support/impl/avutil/58/AVUtilImpl.cpp
+@@ -0,0 +1,39 @@
++/**********************************************************************
++
++ Audacity: A Digital Audio Editor
++
++ AVUtilImpl.cpp
++
++ Dmitry Vedenko
++
++**********************************************************************/
++
++extern "C"
++{
++#include "../../avutil/58/avconfig.h"
++#include "../../ffmpeg-6.0.0-single-header.h"
++}
++
++#include <wx/log.h>
++
++#include "FFmpegFunctions.h"
++
++#include "wrappers/AVFrameWrapper.h"
++
++#include "../../FFmpegAPIResolver.h"
++#include "../../FFmpegLog.h"
++
++namespace avutil_58
++{
++#include "../AVFrameWrapperImpl.inl"
++#include "../FFmpegLogImpl.inl"
++
++const bool registered = ([]() {
++ FFmpegAPIResolver::Get().AddAVUtilFactories(58, {
++ &CreateAVFrameWrapper,
++ &CreateLogCallbackSetter
++ });
++
++ return true;
++})();
++}
+diff --git a/libraries/lib-ffmpeg-support/impl/avutil/58/avconfig.h b/libraries/lib-ffmpeg-support/impl/avutil/58/avconfig.h
+new file mode 100644
+index 00000000000..f6685b72c19
+--- /dev/null
++++ b/libraries/lib-ffmpeg-support/impl/avutil/58/avconfig.h
+@@ -0,0 +1,8 @@
++/* Generated by ffconf */
++#ifndef AVUTIL_AVCONFIG_H
++#define AVUTIL_AVCONFIG_H
++#define AV_HAVE_BIGENDIAN 0
++#define AV_HAVE_FAST_UNALIGNED 1
++#define AV_HAVE_INCOMPATIBLE_LIBAV_ABI 0
++#define AV_HAVE_INCOMPATIBLE_FORK_ABI 0
++#endif /* AVUTIL_AVCONFIG_H */
1 year
- 1
- 0