From 17e32c9aa3c232cea0e0e44844532fb9fc77c97c Mon Sep 17 00:00:00 2001 From: Dan Horák Date: Oct 28 2023 07:48:22 +0000 Subject: initial ppc64 support - docs are disabled - they need qtbase 5.13 to build - missing ffmpeg files - same as is 5.11, we should update the clean-up script not to remove them - drop ffmpeg/scripts/ changes from my qtchromium fork for final Fedora patch - chromium patchset taken from Shawn with little updates from q66 (bundled chromium too old?) --- diff --git a/qt5-qtwebengine.spec b/qt5-qtwebengine.spec index 850171d..266c7cb 100644 --- a/qt5-qtwebengine.spec +++ b/qt5-qtwebengine.spec @@ -126,9 +126,15 @@ Patch50: 0001-avcodec-x86-mathops-clip-constants-used-with-shift-i.patch ## Upstream patches: +## ppc64le port +Patch100: qtwebengine-5.13.2-ppc64.patch +Patch101: qtwebengine-chromium-5.13.2-ppc64.patch +# add missing files +Patch102: qtwebengine-chromium-5.11.1-ffmpeg-ppc64.patch + %if 0%{?fedora} || 0%{?epel} > 7 # handled by qt5-srpm-macros, which defines %%qt5_qtwebengine_arches -ExclusiveArch: %{qt5_qtwebengine_arches} +ExclusiveArch: %{qt5_qtwebengine_arches} ppc64le %endif BuildRequires: make @@ -459,6 +465,15 @@ popd %patch50 -p1 -b .0001-avcodec-x86-mathops-clip-constants-used-with-shift-i +# ppc64le support +%patch100 -p1 +pushd src/3rdparty +%patch101 -p1 +pushd chromium/third_party/ffmpeg +%patch102 -p1 +popd +popd + # delete all "toolprefix = " lines from build/toolchain/linux/BUILD.gn, as we # never cross-compile in native Fedora RPMs, fixes ARM and aarch64 FTBFS sed -i -e '/toolprefix = /d' -e 's/\${toolprefix}//g' \ @@ -502,6 +517,12 @@ fi # abort if this doesn't get created by syncqt.pl test -f "./include/QtWebEngineCore/qtwebenginecoreglobal.h" +# ffmepg build workaround for ppc64le +%ifarch ppc64le +pushd src/3rdparty/chromium/third_party/ffmpeg +mv ffmpeg_generated.gni.ppc64 ffmpeg_generated.gni +popd +%endif %build %if 0%{?rhel} == 7 diff --git a/qtwebengine-5.13.2-ppc64.patch b/qtwebengine-5.13.2-ppc64.patch new file mode 100644 index 0000000..cb53816 --- /dev/null +++ b/qtwebengine-5.13.2-ppc64.patch @@ -0,0 +1,37 @@ +From 43200931cf76b8492d6b2f7c4304dcf121c3e84b Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 11:56:23 +0100 +Subject: [PATCH] ppc64 support + +--- + mkspecs/features/functions.prf | 1 + + mkspecs/features/platform.prf | 1 + + 2 files changed, 2 insertions(+) + +diff --git a/mkspecs/features/functions.prf b/mkspecs/features/functions.prf +index d3eda85b..b117e615 100644 +--- a/mkspecs/features/functions.prf ++++ b/mkspecs/features/functions.prf +@@ -85,6 +85,7 @@ defineReplace(gnArch) { + contains(qtArch, "arm64"): return(arm64) + contains(qtArch, "mips"): return(mipsel) + contains(qtArch, "mips64"): return(mips64el) ++ contains(qtArch, "power64"): return(ppc64) + return(unknown) + } + +diff --git a/mkspecs/features/platform.prf b/mkspecs/features/platform.prf +index 67be73f7..9d2bdc6d 100644 +--- a/mkspecs/features/platform.prf ++++ b/mkspecs/features/platform.prf +@@ -84,6 +84,7 @@ defineTest(isArchSupported) { + contains(QT_ARCH, "arm")|contains(QT_ARCH, "arm64"): return(true) + contains(QT_ARCH, "mips"): return(true) + # contains(QT_ARCH, "mips64"): return(true) ++ contains(QT_ARCH, "power64"): return(true) + + skipBuild("QtWebEngine can only be built for x86, x86-64, ARM, Aarch64, and MIPSel architectures.") + return(false) +-- +2.21.1 + diff --git a/qtwebengine-chromium-5.11.1-ffmpeg-ppc64.patch b/qtwebengine-chromium-5.11.1-ffmpeg-ppc64.patch new file mode 100644 index 0000000..aa71d1a --- /dev/null +++ b/qtwebengine-chromium-5.11.1-ffmpeg-ppc64.patch @@ -0,0 +1,3984 @@ +diff -Nrup ffmpeg.orig/libavcodec/ppc/fft_altivec.S ffmpeg/libavcodec/ppc/fft_altivec.S +--- ffmpeg.orig/libavcodec/ppc/fft_altivec.S 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/fft_altivec.S 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,458 @@ ++/* ++ * FFT transform with Altivec optimizations ++ * Copyright (c) 2009 Loren Merritt ++ * ++ * This algorithm (though not any of the implementation details) is ++ * based on libdjbfft by D. J. Bernstein. ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/* ++ * These functions are not individually interchangeable with the C versions. ++ * While C takes arrays of FFTComplex, Altivec leaves intermediate results ++ * in blocks as convenient to the vector size. ++ * i.e. {4x real, 4x imaginary, 4x real, ...} ++ * ++ * I ignore standard calling convention. ++ * Instead, the following registers are treated as global constants: ++ * v14: zero ++ * v15..v18: cosines ++ * v19..v29: permutations ++ * r9: 16 ++ * r12: ff_cos_tabs ++ * and the rest are free for local use. ++ */ ++ ++#include "config.h" ++ ++#if HAVE_GNU_AS && HAVE_ALTIVEC && HAVE_BIGENDIAN ++ ++#include "asm.S" ++ ++.text ++ ++.macro addi2 ra, imm // add 32-bit immediate ++.if \imm & 0xffff ++ addi \ra, \ra, \imm@l ++.endif ++.if (\imm+0x8000)>>16 ++ addis \ra, \ra, \imm@ha ++.endif ++.endm ++ ++.macro FFT4 a0, a1, a2, a3 // in:0-1 out:2-3 ++ vperm \a2,\a0,\a1,v20 // vcprm(0,1,s2,s1) // {r0,i0,r3,i2} ++ vperm \a3,\a0,\a1,v21 // vcprm(2,3,s0,s3) // {r1,i1,r2,i3} ++ vaddfp \a0,\a2,\a3 // {t1,t2,t6,t5} ++ vsubfp \a1,\a2,\a3 // {t3,t4,t8,t7} ++ vmrghw \a2,\a0,\a1 // vcprm(0,s0,1,s1) // {t1,t3,t2,t4} ++ vperm \a3,\a0,\a1,v22 // vcprm(2,s3,3,s2) // {t6,t7,t5,t8} ++ vaddfp \a0,\a2,\a3 // {r0,r1,i0,i1} ++ vsubfp \a1,\a2,\a3 // {r2,r3,i2,i3} ++ vperm \a2,\a0,\a1,v23 // vcprm(0,1,s0,s1) // {r0,r1,r2,r3} ++ vperm \a3,\a0,\a1,v24 // vcprm(2,3,s2,s3) // {i0,i1,i2,i3} ++.endm ++ ++.macro FFT4x2 a0, a1, b0, b1, a2, a3, b2, b3 ++ vperm \a2,\a0,\a1,v20 // vcprm(0,1,s2,s1) // {r0,i0,r3,i2} ++ vperm \a3,\a0,\a1,v21 // vcprm(2,3,s0,s3) // {r1,i1,r2,i3} ++ vperm \b2,\b0,\b1,v20 ++ vperm \b3,\b0,\b1,v21 ++ vaddfp \a0,\a2,\a3 // {t1,t2,t6,t5} ++ vsubfp \a1,\a2,\a3 // {t3,t4,t8,t7} ++ vaddfp \b0,\b2,\b3 ++ vsubfp \b1,\b2,\b3 ++ vmrghw \a2,\a0,\a1 // vcprm(0,s0,1,s1) // {t1,t3,t2,t4} ++ vperm \a3,\a0,\a1,v22 // vcprm(2,s3,3,s2) // {t6,t7,t5,t8} ++ vmrghw \b2,\b0,\b1 ++ vperm \b3,\b0,\b1,v22 ++ vaddfp \a0,\a2,\a3 // {r0,r1,i0,i1} ++ vsubfp \a1,\a2,\a3 // {r2,r3,i2,i3} ++ vaddfp \b0,\b2,\b3 ++ vsubfp \b1,\b2,\b3 ++ vperm \a2,\a0,\a1,v23 // vcprm(0,1,s0,s1) // {r0,r1,r2,r3} ++ vperm \a3,\a0,\a1,v24 // vcprm(2,3,s2,s3) // {i0,i1,i2,i3} ++ vperm \b2,\b0,\b1,v23 ++ vperm \b3,\b0,\b1,v24 ++.endm ++ ++.macro FFT8 a0, a1, b0, b1, a2, a3, b2, b3, b4 // in,out:a0-b1 ++ vmrghw \b2,\b0,\b1 // vcprm(0,s0,1,s1) // {r4,r6,i4,i6} ++ vmrglw \b3,\b0,\b1 // vcprm(2,s2,3,s3) // {r5,r7,i5,i7} ++ vperm \a2,\a0,\a1,v20 // FFT4 ... ++ vperm \a3,\a0,\a1,v21 ++ vaddfp \b0,\b2,\b3 // {t1,t3,t2,t4} ++ vsubfp \b1,\b2,\b3 // {r5,r7,i5,i7} ++ vperm \b4,\b1,\b1,v25 // vcprm(2,3,0,1) // {i5,i7,r5,r7} ++ vaddfp \a0,\a2,\a3 ++ vsubfp \a1,\a2,\a3 ++ vmaddfp \b1,\b1,v17,v14 // * {-1,1,1,-1}/sqrt(2) ++ vmaddfp \b1,\b4,v18,\b1 // * { 1,1,1,1 }/sqrt(2) // {t8,ta,t7,t9} ++ vmrghw \a2,\a0,\a1 ++ vperm \a3,\a0,\a1,v22 ++ vperm \b2,\b0,\b1,v26 // vcprm(1,2,s3,s0) // {t3,t2,t9,t8} ++ vperm \b3,\b0,\b1,v27 // vcprm(0,3,s2,s1) // {t1,t4,t7,ta} ++ vaddfp \a0,\a2,\a3 ++ vsubfp \a1,\a2,\a3 ++ vaddfp \b0,\b2,\b3 // {t1,t2,t9,ta} ++ vsubfp \b1,\b2,\b3 // {t6,t5,tc,tb} ++ vperm \a2,\a0,\a1,v23 ++ vperm \a3,\a0,\a1,v24 ++ vperm \b2,\b0,\b1,v28 // vcprm(0,2,s1,s3) // {t1,t9,t5,tb} ++ vperm \b3,\b0,\b1,v29 // vcprm(1,3,s0,s2) // {t2,ta,t6,tc} ++ vsubfp \b0,\a2,\b2 // {r4,r5,r6,r7} ++ vsubfp \b1,\a3,\b3 // {i4,i5,i6,i7} ++ vaddfp \a0,\a2,\b2 // {r0,r1,r2,r3} ++ vaddfp \a1,\a3,\b3 // {i0,i1,i2,i3} ++.endm ++ ++.macro BF d0,d1,s0,s1 ++ vsubfp \d1,\s0,\s1 ++ vaddfp \d0,\s0,\s1 ++.endm ++ ++.macro zip d0,d1,s0,s1 ++ vmrghw \d0,\s0,\s1 ++ vmrglw \d1,\s0,\s1 ++.endm ++ ++.macro def_fft4 interleave ++fft4\interleave\()_altivec: ++ lvx v0, 0,r3 ++ lvx v1,r9,r3 ++ FFT4 v0,v1,v2,v3 ++.ifnb \interleave ++ zip v0,v1,v2,v3 ++ stvx v0, 0,r3 ++ stvx v1,r9,r3 ++.else ++ stvx v2, 0,r3 ++ stvx v3,r9,r3 ++.endif ++ blr ++.endm ++ ++.macro def_fft8 interleave ++fft8\interleave\()_altivec: ++ addi r4,r3,32 ++ lvx v0, 0,r3 ++ lvx v1,r9,r3 ++ lvx v2, 0,r4 ++ lvx v3,r9,r4 ++ FFT8 v0,v1,v2,v3,v4,v5,v6,v7,v8 ++.ifnb \interleave ++ zip v4,v5,v0,v1 ++ zip v6,v7,v2,v3 ++ stvx v4, 0,r3 ++ stvx v5,r9,r3 ++ stvx v6, 0,r4 ++ stvx v7,r9,r4 ++.else ++ stvx v0, 0,r3 ++ stvx v1,r9,r3 ++ stvx v2, 0,r4 ++ stvx v3,r9,r4 ++.endif ++ blr ++.endm ++ ++.macro def_fft16 interleave ++fft16\interleave\()_altivec: ++ addi r5,r3,64 ++ addi r6,r3,96 ++ addi r4,r3,32 ++ lvx v0, 0,r5 ++ lvx v1,r9,r5 ++ lvx v2, 0,r6 ++ lvx v3,r9,r6 ++ FFT4x2 v0,v1,v2,v3,v4,v5,v6,v7 ++ lvx v0, 0,r3 ++ lvx v1,r9,r3 ++ lvx v2, 0,r4 ++ lvx v3,r9,r4 ++ FFT8 v0,v1,v2,v3,v8,v9,v10,v11,v12 ++ vmaddfp v8,v4,v15,v14 // r2*wre ++ vmaddfp v9,v5,v15,v14 // i2*wre ++ vmaddfp v10,v6,v15,v14 // r3*wre ++ vmaddfp v11,v7,v15,v14 // i3*wre ++ vmaddfp v8,v5,v16,v8 // i2*wim ++ vnmsubfp v9,v4,v16,v9 // r2*wim ++ vnmsubfp v10,v7,v16,v10 // i3*wim ++ vmaddfp v11,v6,v16,v11 // r3*wim ++ BF v10,v12,v10,v8 ++ BF v11,v13,v9,v11 ++ BF v0,v4,v0,v10 ++ BF v3,v7,v3,v12 ++ BF v1,v5,v1,v11 ++ BF v2,v6,v2,v13 ++.ifnb \interleave ++ zip v8, v9,v0,v1 ++ zip v10,v11,v2,v3 ++ zip v12,v13,v4,v5 ++ zip v14,v15,v6,v7 ++ stvx v8, 0,r3 ++ stvx v9,r9,r3 ++ stvx v10, 0,r4 ++ stvx v11,r9,r4 ++ stvx v12, 0,r5 ++ stvx v13,r9,r5 ++ stvx v14, 0,r6 ++ stvx v15,r9,r6 ++.else ++ stvx v0, 0,r3 ++ stvx v4, 0,r5 ++ stvx v3,r9,r4 ++ stvx v7,r9,r6 ++ stvx v1,r9,r3 ++ stvx v5,r9,r5 ++ stvx v2, 0,r4 ++ stvx v6, 0,r6 ++.endif ++ blr ++.endm ++ ++// void pass(float *z, float *wre, int n) ++.macro PASS interleave, suffix ++fft_pass\suffix\()_altivec: ++ mtctr r5 ++ slwi r0,r5,4 ++ slwi r7,r5,6 // o2 ++ slwi r5,r5,5 // o1 ++ add r10,r5,r7 // o3 ++ add r0,r4,r0 // wim ++ addi r6,r5,16 // o1+16 ++ addi r8,r7,16 // o2+16 ++ addi r11,r10,16 // o3+16 ++1: ++ lvx v8, 0,r4 // wre ++ lvx v10, 0,r0 // wim ++ sub r0,r0,r9 ++ lvx v9, 0,r0 ++ vperm v9,v9,v10,v19 // vcprm(s0,3,2,1) => wim[0 .. -3] ++ lvx v4,r3,r7 // r2 = z[o2] ++ lvx v5,r3,r8 // i2 = z[o2+16] ++ lvx v6,r3,r10 // r3 = z[o3] ++ lvx v7,r3,r11 // i3 = z[o3+16] ++ vmaddfp v10,v4,v8,v14 // r2*wre ++ vmaddfp v11,v5,v8,v14 // i2*wre ++ vmaddfp v12,v6,v8,v14 // r3*wre ++ vmaddfp v13,v7,v8,v14 // i3*wre ++ lvx v0, 0,r3 // r0 = z[0] ++ lvx v3,r3,r6 // i1 = z[o1+16] ++ vmaddfp v10,v5,v9,v10 // i2*wim ++ vnmsubfp v11,v4,v9,v11 // r2*wim ++ vnmsubfp v12,v7,v9,v12 // i3*wim ++ vmaddfp v13,v6,v9,v13 // r3*wim ++ lvx v1,r3,r9 // i0 = z[16] ++ lvx v2,r3,r5 // r1 = z[o1] ++ BF v12,v8,v12,v10 ++ BF v13,v9,v11,v13 ++ BF v0,v4,v0,v12 ++ BF v3,v7,v3,v8 ++.if !\interleave ++ stvx v0, 0,r3 ++ stvx v4,r3,r7 ++ stvx v3,r3,r6 ++ stvx v7,r3,r11 ++.endif ++ BF v1,v5,v1,v13 ++ BF v2,v6,v2,v9 ++.if !\interleave ++ stvx v1,r3,r9 ++ stvx v2,r3,r5 ++ stvx v5,r3,r8 ++ stvx v6,r3,r10 ++.else ++ vmrghw v8,v0,v1 ++ vmrglw v9,v0,v1 ++ stvx v8, 0,r3 ++ stvx v9,r3,r9 ++ vmrghw v8,v2,v3 ++ vmrglw v9,v2,v3 ++ stvx v8,r3,r5 ++ stvx v9,r3,r6 ++ vmrghw v8,v4,v5 ++ vmrglw v9,v4,v5 ++ stvx v8,r3,r7 ++ stvx v9,r3,r8 ++ vmrghw v8,v6,v7 ++ vmrglw v9,v6,v7 ++ stvx v8,r3,r10 ++ stvx v9,r3,r11 ++.endif ++ addi r3,r3,32 ++ addi r4,r4,16 ++ bdnz 1b ++ sub r3,r3,r5 ++ blr ++.endm ++ ++#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ ++ ++#define WORD_0 0x00,0x01,0x02,0x03 ++#define WORD_1 0x04,0x05,0x06,0x07 ++#define WORD_2 0x08,0x09,0x0a,0x0b ++#define WORD_3 0x0c,0x0d,0x0e,0x0f ++#define WORD_s0 0x10,0x11,0x12,0x13 ++#define WORD_s1 0x14,0x15,0x16,0x17 ++#define WORD_s2 0x18,0x19,0x1a,0x1b ++#define WORD_s3 0x1c,0x1d,0x1e,0x1f ++ ++#define vcprm(a, b, c, d) .byte WORD_##a, WORD_##b, WORD_##c, WORD_##d ++ ++ .rodata ++ .align 4 ++fft_data: ++ .float 0, 0, 0, 0 ++ .float 1, 0.92387953, M_SQRT1_2, 0.38268343 ++ .float 0, 0.38268343, M_SQRT1_2, 0.92387953 ++ .float -M_SQRT1_2, M_SQRT1_2, M_SQRT1_2,-M_SQRT1_2 ++ .float M_SQRT1_2, M_SQRT1_2, M_SQRT1_2, M_SQRT1_2 ++ vcprm(s0,3,2,1) ++ vcprm(0,1,s2,s1) ++ vcprm(2,3,s0,s3) ++ vcprm(2,s3,3,s2) ++ vcprm(0,1,s0,s1) ++ vcprm(2,3,s2,s3) ++ vcprm(2,3,0,1) ++ vcprm(1,2,s3,s0) ++ vcprm(0,3,s2,s1) ++ vcprm(0,2,s1,s3) ++ vcprm(1,3,s0,s2) ++ ++.macro lvm b, r, regs:vararg ++ lvx \r, 0, \b ++ addi \b, \b, 16 ++ .ifnb \regs ++ lvm \b, \regs ++ .endif ++.endm ++ ++.macro stvm b, r, regs:vararg ++ stvx \r, 0, \b ++ addi \b, \b, 16 ++ .ifnb \regs ++ stvm \b, \regs ++ .endif ++.endm ++ ++.macro fft_calc interleave ++extfunc ff_fft_calc\interleave\()_altivec ++ mflr r0 ++ stp r0, 2*PS(R(1)) ++ stpu r1, -(160+16*PS)(R(1)) ++ get_got r11 ++ addi r6, r1, 16*PS ++ stvm r6, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29 ++ mfvrsave r0 ++ stw r0, 15*PS(R(1)) ++#if __APPLE__ ++ li r6, 0xfffffffc ++#else ++ li r6, -4 ++#endif ++ mtvrsave r6 ++ ++ movrel r6, fft_data, r11 ++ lvm r6, v14, v15, v16, v17, v18, v19, v20, v21 ++ lvm r6, v22, v23, v24, v25, v26, v27, v28, v29 ++ ++ li r9, 16 ++ movrel r12, X(ff_cos_tabs), r11 ++ ++ movrel r6, fft_dispatch_tab\interleave\()_altivec, r11 ++ lwz r3, 0(R(3)) ++ subi r3, r3, 2 ++ slwi r3, r3, 2+ARCH_PPC64 ++ lpx r3, r3, r6 ++ mtctr r3 ++ mr r3, r4 ++ bctrl ++ ++ addi r6, r1, 16*PS ++ lvm r6, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29 ++ lwz r6, 15*PS(R(1)) ++ mtvrsave r6 ++ lp r1, 0(R(1)) ++ lp r0, 2*PS(R(1)) ++ mtlr r0 ++ blr ++.endm ++ ++.macro DECL_FFT suffix, bits, n, n2, n4 ++fft\n\suffix\()_altivec: ++ mflr r0 ++ stp r0,PS*(\bits-3)(R(1)) ++ bl fft\n2\()_altivec ++ addi2 r3,\n*4 ++ bl fft\n4\()_altivec ++ addi2 r3,\n*2 ++ bl fft\n4\()_altivec ++ addi2 r3,\n*-6 ++ lp r0,PS*(\bits-3)(R(1)) ++ lp r4,\bits*PS(R(12)) ++ mtlr r0 ++ li r5,\n/16 ++ b fft_pass\suffix\()_altivec ++.endm ++ ++.macro DECL_FFTS interleave, suffix ++ .text ++ def_fft4 \suffix ++ def_fft8 \suffix ++ def_fft16 \suffix ++ PASS \interleave, \suffix ++ DECL_FFT \suffix, 5, 32, 16, 8 ++ DECL_FFT \suffix, 6, 64, 32, 16 ++ DECL_FFT \suffix, 7, 128, 64, 32 ++ DECL_FFT \suffix, 8, 256, 128, 64 ++ DECL_FFT \suffix, 9, 512, 256, 128 ++ DECL_FFT \suffix,10, 1024, 512, 256 ++ DECL_FFT \suffix,11, 2048, 1024, 512 ++ DECL_FFT \suffix,12, 4096, 2048, 1024 ++ DECL_FFT \suffix,13, 8192, 4096, 2048 ++ DECL_FFT \suffix,14,16384, 8192, 4096 ++ DECL_FFT \suffix,15,32768,16384, 8192 ++ DECL_FFT \suffix,16,65536,32768,16384 ++ ++ fft_calc \suffix ++ ++ .rodata ++ .align 3 ++fft_dispatch_tab\suffix\()_altivec: ++ PTR fft4\suffix\()_altivec ++ PTR fft8\suffix\()_altivec ++ PTR fft16\suffix\()_altivec ++ PTR fft32\suffix\()_altivec ++ PTR fft64\suffix\()_altivec ++ PTR fft128\suffix\()_altivec ++ PTR fft256\suffix\()_altivec ++ PTR fft512\suffix\()_altivec ++ PTR fft1024\suffix\()_altivec ++ PTR fft2048\suffix\()_altivec ++ PTR fft4096\suffix\()_altivec ++ PTR fft8192\suffix\()_altivec ++ PTR fft16384\suffix\()_altivec ++ PTR fft32768\suffix\()_altivec ++ PTR fft65536\suffix\()_altivec ++.endm ++ ++DECL_FFTS 0 ++DECL_FFTS 1, _interleave ++ ++#endif /* HAVE_GNU_AS && HAVE_ALTIVEC && HAVE_BIGENDIAN */ +diff -Nrup ffmpeg.orig/libavcodec/ppc/fft_init.c ffmpeg/libavcodec/ppc/fft_init.c +--- ffmpeg.orig/libavcodec/ppc/fft_init.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/fft_init.c 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,167 @@ ++/* ++ * FFT/IFFT transforms ++ * AltiVec-enabled ++ * Copyright (c) 2009 Loren Merritt ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "config.h" ++#include "libavutil/cpu.h" ++#include "libavutil/ppc/cpu.h" ++#include "libavutil/ppc/util_altivec.h" ++#include "libavcodec/fft.h" ++ ++/** ++ * Do a complex FFT with the parameters defined in ff_fft_init(). ++ * The input data must be permuted before with s->revtab table. ++ * No 1.0 / sqrt(n) normalization is done. ++ * AltiVec-enabled: ++ * This code assumes that the 'z' pointer is 16 bytes-aligned. ++ * It also assumes all FFTComplex are 8 bytes-aligned pairs of floats. ++ */ ++ ++#if HAVE_VSX ++#include "fft_vsx.h" ++#else ++void ff_fft_calc_altivec(FFTContext *s, FFTComplex *z); ++void ff_fft_calc_interleave_altivec(FFTContext *s, FFTComplex *z); ++#endif ++ ++#if HAVE_GNU_AS && HAVE_ALTIVEC && (HAVE_BIGENDIAN || HAVE_VSX) ++static void imdct_half_altivec(FFTContext *s, FFTSample *output, const FFTSample *input) ++{ ++ int j, k; ++ int n = 1 << s->mdct_bits; ++ int n4 = n >> 2; ++ int n8 = n >> 3; ++ int n32 = n >> 5; ++ const uint16_t *revtabj = s->revtab; ++ const uint16_t *revtabk = s->revtab+n4; ++ const vec_f *tcos = (const vec_f*)(s->tcos+n8); ++ const vec_f *tsin = (const vec_f*)(s->tsin+n8); ++ const vec_f *pin = (const vec_f*)(input+n4); ++ vec_f *pout = (vec_f*)(output+n4); ++ ++ /* pre rotation */ ++ k = n32-1; ++ do { ++ vec_f cos,sin,cos0,sin0,cos1,sin1,re,im,r0,i0,r1,i1,a,b,c,d; ++#define CMULA(p,o0,o1,o2,o3)\ ++ a = pin[ k*2+p]; /* { z[k].re, z[k].im, z[k+1].re, z[k+1].im } */\ ++ b = pin[-k*2-p-1]; /* { z[-k-2].re, z[-k-2].im, z[-k-1].re, z[-k-1].im } */\ ++ re = vec_perm(a, b, vcprm(0,2,s0,s2)); /* { z[k].re, z[k+1].re, z[-k-2].re, z[-k-1].re } */\ ++ im = vec_perm(a, b, vcprm(s3,s1,3,1)); /* { z[-k-1].im, z[-k-2].im, z[k+1].im, z[k].im } */\ ++ cos = vec_perm(cos0, cos1, vcprm(o0,o1,s##o2,s##o3)); /* { cos[k], cos[k+1], cos[-k-2], cos[-k-1] } */\ ++ sin = vec_perm(sin0, sin1, vcprm(o0,o1,s##o2,s##o3));\ ++ r##p = im*cos - re*sin;\ ++ i##p = re*cos + im*sin; ++#define STORE2(v,dst)\ ++ j = dst;\ ++ vec_ste(v, 0, output+j*2);\ ++ vec_ste(v, 4, output+j*2); ++#define STORE8(p)\ ++ a = vec_perm(r##p, i##p, vcprm(0,s0,0,s0));\ ++ b = vec_perm(r##p, i##p, vcprm(1,s1,1,s1));\ ++ c = vec_perm(r##p, i##p, vcprm(2,s2,2,s2));\ ++ d = vec_perm(r##p, i##p, vcprm(3,s3,3,s3));\ ++ STORE2(a, revtabk[ p*2-4]);\ ++ STORE2(b, revtabk[ p*2-3]);\ ++ STORE2(c, revtabj[-p*2+2]);\ ++ STORE2(d, revtabj[-p*2+3]); ++ ++ cos0 = tcos[k]; ++ sin0 = tsin[k]; ++ cos1 = tcos[-k-1]; ++ sin1 = tsin[-k-1]; ++ CMULA(0, 0,1,2,3); ++ CMULA(1, 2,3,0,1); ++ STORE8(0); ++ STORE8(1); ++ revtabj += 4; ++ revtabk -= 4; ++ k--; ++ } while(k >= 0); ++ ++#if HAVE_VSX ++ ff_fft_calc_vsx(s, (FFTComplex*)output); ++#else ++ ff_fft_calc_altivec(s, (FFTComplex*)output); ++#endif ++ ++ /* post rotation + reordering */ ++ j = -n32; ++ k = n32-1; ++ do { ++ vec_f cos,sin,re,im,a,b,c,d; ++#define CMULB(d0,d1,o)\ ++ re = pout[o*2];\ ++ im = pout[o*2+1];\ ++ cos = tcos[o];\ ++ sin = tsin[o];\ ++ d0 = im*sin - re*cos;\ ++ d1 = re*sin + im*cos; ++ ++ CMULB(a,b,j); ++ CMULB(c,d,k); ++ pout[2*j] = vec_perm(a, d, vcprm(0,s3,1,s2)); ++ pout[2*j+1] = vec_perm(a, d, vcprm(2,s1,3,s0)); ++ pout[2*k] = vec_perm(c, b, vcprm(0,s3,1,s2)); ++ pout[2*k+1] = vec_perm(c, b, vcprm(2,s1,3,s0)); ++ j++; ++ k--; ++ } while(k >= 0); ++} ++ ++static void imdct_calc_altivec(FFTContext *s, FFTSample *output, const FFTSample *input) ++{ ++ int k; ++ int n = 1 << s->mdct_bits; ++ int n4 = n >> 2; ++ int n16 = n >> 4; ++ vec_u32 sign = {1U<<31,1U<<31,1U<<31,1U<<31}; ++ vec_u32 *p0 = (vec_u32*)(output+n4); ++ vec_u32 *p1 = (vec_u32*)(output+n4*3); ++ ++ imdct_half_altivec(s, output + n4, input); ++ ++ for (k = 0; k < n16; k++) { ++ vec_u32 a = p0[k] ^ sign; ++ vec_u32 b = p1[-k-1]; ++ p0[-k-1] = vec_perm(a, a, vcprm(3,2,1,0)); ++ p1[k] = vec_perm(b, b, vcprm(3,2,1,0)); ++ } ++} ++#endif /* HAVE_GNU_AS && HAVE_ALTIVEC && (HAVE_BIGENDIAN || HAVE_VSX) */ ++ ++av_cold void ff_fft_init_ppc(FFTContext *s) ++{ ++#if HAVE_GNU_AS && HAVE_ALTIVEC && (HAVE_BIGENDIAN || HAVE_VSX) ++ if (!PPC_ALTIVEC(av_get_cpu_flags())) ++ return; ++ ++#if HAVE_VSX ++ s->fft_calc = ff_fft_calc_interleave_vsx; ++#else ++ s->fft_calc = ff_fft_calc_interleave_altivec; ++#endif ++ if (s->mdct_bits >= 5) { ++ s->imdct_calc = imdct_calc_altivec; ++ s->imdct_half = imdct_half_altivec; ++ } ++#endif /* HAVE_GNU_AS && HAVE_ALTIVEC && HAVE_BIGENDIAN */ ++} +diff -Nrup ffmpeg.orig/libavcodec/ppc/fft_vsx.c ffmpeg/libavcodec/ppc/fft_vsx.c +--- ffmpeg.orig/libavcodec/ppc/fft_vsx.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/fft_vsx.c 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,226 @@ ++/* ++ * FFT transform, optimized with VSX built-in functions ++ * Copyright (c) 2014 Rong Yan ++ * ++ * This algorithm (though not any of the implementation details) is ++ * based on libdjbfft by D. J. Bernstein. ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++ ++#include "config.h" ++#include "libavutil/cpu.h" ++#include "libavutil/ppc/util_altivec.h" ++#include "libavcodec/fft.h" ++#include "libavcodec/fft-internal.h" ++#include "fft_vsx.h" ++ ++#if HAVE_VSX ++ ++static void fft32_vsx_interleave(FFTComplex *z) ++{ ++ fft16_vsx_interleave(z); ++ fft8_vsx_interleave(z+16); ++ fft8_vsx_interleave(z+24); ++ pass_vsx_interleave(z,ff_cos_32,4); ++} ++ ++static void fft64_vsx_interleave(FFTComplex *z) ++{ ++ fft32_vsx_interleave(z); ++ fft16_vsx_interleave(z+32); ++ fft16_vsx_interleave(z+48); ++ pass_vsx_interleave(z,ff_cos_64, 8); ++} ++static void fft128_vsx_interleave(FFTComplex *z) ++{ ++ fft64_vsx_interleave(z); ++ fft32_vsx_interleave(z+64); ++ fft32_vsx_interleave(z+96); ++ pass_vsx_interleave(z,ff_cos_128,16); ++} ++static void fft256_vsx_interleave(FFTComplex *z) ++{ ++ fft128_vsx_interleave(z); ++ fft64_vsx_interleave(z+128); ++ fft64_vsx_interleave(z+192); ++ pass_vsx_interleave(z,ff_cos_256,32); ++} ++static void fft512_vsx_interleave(FFTComplex *z) ++{ ++ fft256_vsx_interleave(z); ++ fft128_vsx_interleave(z+256); ++ fft128_vsx_interleave(z+384); ++ pass_vsx_interleave(z,ff_cos_512,64); ++} ++static void fft1024_vsx_interleave(FFTComplex *z) ++{ ++ fft512_vsx_interleave(z); ++ fft256_vsx_interleave(z+512); ++ fft256_vsx_interleave(z+768); ++ pass_vsx_interleave(z,ff_cos_1024,128); ++ ++} ++static void fft2048_vsx_interleave(FFTComplex *z) ++{ ++ fft1024_vsx_interleave(z); ++ fft512_vsx_interleave(z+1024); ++ fft512_vsx_interleave(z+1536); ++ pass_vsx_interleave(z,ff_cos_2048,256); ++} ++static void fft4096_vsx_interleave(FFTComplex *z) ++{ ++ fft2048_vsx_interleave(z); ++ fft1024_vsx_interleave(z+2048); ++ fft1024_vsx_interleave(z+3072); ++ pass_vsx_interleave(z,ff_cos_4096, 512); ++} ++static void fft8192_vsx_interleave(FFTComplex *z) ++{ ++ fft4096_vsx_interleave(z); ++ fft2048_vsx_interleave(z+4096); ++ fft2048_vsx_interleave(z+6144); ++ pass_vsx_interleave(z,ff_cos_8192,1024); ++} ++static void fft16384_vsx_interleave(FFTComplex *z) ++{ ++ fft8192_vsx_interleave(z); ++ fft4096_vsx_interleave(z+8192); ++ fft4096_vsx_interleave(z+12288); ++ pass_vsx_interleave(z,ff_cos_16384,2048); ++} ++static void fft32768_vsx_interleave(FFTComplex *z) ++{ ++ fft16384_vsx_interleave(z); ++ fft8192_vsx_interleave(z+16384); ++ fft8192_vsx_interleave(z+24576); ++ pass_vsx_interleave(z,ff_cos_32768,4096); ++} ++static void fft65536_vsx_interleave(FFTComplex *z) ++{ ++ fft32768_vsx_interleave(z); ++ fft16384_vsx_interleave(z+32768); ++ fft16384_vsx_interleave(z+49152); ++ pass_vsx_interleave(z,ff_cos_65536,8192); ++} ++ ++static void fft32_vsx(FFTComplex *z) ++{ ++ fft16_vsx(z); ++ fft8_vsx(z+16); ++ fft8_vsx(z+24); ++ pass_vsx(z,ff_cos_32,4); ++} ++ ++static void fft64_vsx(FFTComplex *z) ++{ ++ fft32_vsx(z); ++ fft16_vsx(z+32); ++ fft16_vsx(z+48); ++ pass_vsx(z,ff_cos_64, 8); ++} ++static void fft128_vsx(FFTComplex *z) ++{ ++ fft64_vsx(z); ++ fft32_vsx(z+64); ++ fft32_vsx(z+96); ++ pass_vsx(z,ff_cos_128,16); ++} ++static void fft256_vsx(FFTComplex *z) ++{ ++ fft128_vsx(z); ++ fft64_vsx(z+128); ++ fft64_vsx(z+192); ++ pass_vsx(z,ff_cos_256,32); ++} ++static void fft512_vsx(FFTComplex *z) ++{ ++ fft256_vsx(z); ++ fft128_vsx(z+256); ++ fft128_vsx(z+384); ++ pass_vsx(z,ff_cos_512,64); ++} ++static void fft1024_vsx(FFTComplex *z) ++{ ++ fft512_vsx(z); ++ fft256_vsx(z+512); ++ fft256_vsx(z+768); ++ pass_vsx(z,ff_cos_1024,128); ++ ++} ++static void fft2048_vsx(FFTComplex *z) ++{ ++ fft1024_vsx(z); ++ fft512_vsx(z+1024); ++ fft512_vsx(z+1536); ++ pass_vsx(z,ff_cos_2048,256); ++} ++static void fft4096_vsx(FFTComplex *z) ++{ ++ fft2048_vsx(z); ++ fft1024_vsx(z+2048); ++ fft1024_vsx(z+3072); ++ pass_vsx(z,ff_cos_4096, 512); ++} ++static void fft8192_vsx(FFTComplex *z) ++{ ++ fft4096_vsx(z); ++ fft2048_vsx(z+4096); ++ fft2048_vsx(z+6144); ++ pass_vsx(z,ff_cos_8192,1024); ++} ++static void fft16384_vsx(FFTComplex *z) ++{ ++ fft8192_vsx(z); ++ fft4096_vsx(z+8192); ++ fft4096_vsx(z+12288); ++ pass_vsx(z,ff_cos_16384,2048); ++} ++static void fft32768_vsx(FFTComplex *z) ++{ ++ fft16384_vsx(z); ++ fft8192_vsx(z+16384); ++ fft8192_vsx(z+24576); ++ pass_vsx(z,ff_cos_32768,4096); ++} ++static void fft65536_vsx(FFTComplex *z) ++{ ++ fft32768_vsx(z); ++ fft16384_vsx(z+32768); ++ fft16384_vsx(z+49152); ++ pass_vsx(z,ff_cos_65536,8192); ++} ++ ++static void (* const fft_dispatch_vsx[])(FFTComplex*) = { ++ fft4_vsx, fft8_vsx, fft16_vsx, fft32_vsx, fft64_vsx, fft128_vsx, fft256_vsx, fft512_vsx, fft1024_vsx, ++ fft2048_vsx, fft4096_vsx, fft8192_vsx, fft16384_vsx, fft32768_vsx, fft65536_vsx, ++}; ++static void (* const fft_dispatch_vsx_interleave[])(FFTComplex*) = { ++ fft4_vsx_interleave, fft8_vsx_interleave, fft16_vsx_interleave, fft32_vsx_interleave, fft64_vsx_interleave, ++ fft128_vsx_interleave, fft256_vsx_interleave, fft512_vsx_interleave, fft1024_vsx_interleave, ++ fft2048_vsx_interleave, fft4096_vsx_interleave, fft8192_vsx_interleave, fft16384_vsx_interleave, fft32768_vsx_interleave, fft65536_vsx_interleave, ++}; ++void ff_fft_calc_interleave_vsx(FFTContext *s, FFTComplex *z) ++{ ++ fft_dispatch_vsx_interleave[s->nbits-2](z); ++} ++void ff_fft_calc_vsx(FFTContext *s, FFTComplex *z) ++{ ++ fft_dispatch_vsx[s->nbits-2](z); ++} ++#endif /* HAVE_VSX */ +diff -Nrup ffmpeg.orig/libavcodec/ppc/fft_vsx.h ffmpeg/libavcodec/ppc/fft_vsx.h +--- ffmpeg.orig/libavcodec/ppc/fft_vsx.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/fft_vsx.h 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,829 @@ ++#ifndef AVCODEC_PPC_FFT_VSX_H ++#define AVCODEC_PPC_FFT_VSX_H ++/* ++ * FFT transform, optimized with VSX built-in functions ++ * Copyright (c) 2014 Rong Yan Copyright (c) 2009 Loren Merritt ++ * ++ * This algorithm (though not any of the implementation details) is ++ * based on libdjbfft by D. J. Bernstein, and fft_altivec_s.S. ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++ ++#include "config.h" ++#include "libavutil/cpu.h" ++#include "libavutil/ppc/util_altivec.h" ++#include "libavcodec/fft.h" ++#include "libavcodec/fft-internal.h" ++ ++#if HAVE_VSX ++ ++void ff_fft_calc_interleave_vsx(FFTContext *s, FFTComplex *z); ++void ff_fft_calc_vsx(FFTContext *s, FFTComplex *z); ++ ++ ++#define byte_2complex (2*sizeof(FFTComplex)) ++#define byte_4complex (4*sizeof(FFTComplex)) ++#define byte_6complex (6*sizeof(FFTComplex)) ++#define byte_8complex (8*sizeof(FFTComplex)) ++#define byte_10complex (10*sizeof(FFTComplex)) ++#define byte_12complex (12*sizeof(FFTComplex)) ++#define byte_14complex (14*sizeof(FFTComplex)) ++ ++inline static void pass_vsx_interleave(FFTComplex *z, const FFTSample *wre, unsigned int n) ++{ ++ int o1 = n<<1; ++ int o2 = n<<2; ++ int o3 = o1+o2; ++ int i1, i2, i3; ++ FFTSample* out = (FFTSample*)z; ++ const FFTSample *wim = wre+o1; ++ vec_f vz0, vzo1, vzo2, vzo3; ++ vec_f x0, x1, x2, x3; ++ vec_f x4, x5, x6, x7; ++ vec_f x8, x9, x10, x11; ++ vec_f x12, x13, x14, x15; ++ vec_f x16, x17, x18, x19; ++ vec_f x20, x21, x22, x23; ++ vec_f vz0plus1, vzo1plus1, vzo2plus1, vzo3plus1; ++ vec_f y0, y1, y2, y3; ++ vec_f y4, y5, y8, y9; ++ vec_f y10, y13, y14, y15; ++ vec_f y16, y17, y18, y19; ++ vec_f y20, y21, y22, y23; ++ vec_f wr1, wi1, wr0, wi0; ++ vec_f wr2, wi2, wr3, wi3; ++ vec_f xmulwi0, xmulwi1, ymulwi2, ymulwi3; ++ ++ n = n-2; ++ i1 = o1*sizeof(FFTComplex); ++ i2 = o2*sizeof(FFTComplex); ++ i3 = o3*sizeof(FFTComplex); ++ vzo2 = vec_ld(i2, &(out[0])); // zo2.r zo2.i z(o2+1).r z(o2+1).i ++ vzo2plus1 = vec_ld(i2+16, &(out[0])); ++ vzo3 = vec_ld(i3, &(out[0])); // zo3.r zo3.i z(o3+1).r z(o3+1).i ++ vzo3plus1 = vec_ld(i3+16, &(out[0])); ++ vz0 = vec_ld(0, &(out[0])); // z0.r z0.i z1.r z1.i ++ vz0plus1 = vec_ld(16, &(out[0])); ++ vzo1 = vec_ld(i1, &(out[0])); // zo1.r zo1.i z(o1+1).r z(o1+1).i ++ vzo1plus1 = vec_ld(i1+16, &(out[0])); ++ ++ x0 = vec_add(vzo2, vzo3); ++ x1 = vec_sub(vzo2, vzo3); ++ y0 = vec_add(vzo2plus1, vzo3plus1); ++ y1 = vec_sub(vzo2plus1, vzo3plus1); ++ ++ wr1 = vec_splats(wre[1]); ++ wi1 = vec_splats(wim[-1]); ++ wi2 = vec_splats(wim[-2]); ++ wi3 = vec_splats(wim[-3]); ++ wr2 = vec_splats(wre[2]); ++ wr3 = vec_splats(wre[3]); ++ ++ x2 = vec_perm(x0, x1, vcprm(2,s2,3,s3)); ++ x3 = vec_perm(x0, x1, vcprm(s3,3,s2,2)); ++ ++ y4 = vec_perm(y0, y1, vcprm(s1,1,s0,0)); ++ y5 = vec_perm(y0, y1, vcprm(s3,3,s2,2)); ++ y2 = vec_perm(y0, y1, vcprm(0,s0,1,s1)); ++ y3 = vec_perm(y0, y1, vcprm(2,s2,3,s3)); ++ ++ ymulwi2 = vec_mul(y4, wi2); ++ ymulwi3 = vec_mul(y5, wi3); ++ x4 = vec_mul(x2, wr1); ++ x5 = vec_mul(x3, wi1); ++ y8 = vec_madd(y2, wr2, ymulwi2); ++ y9 = vec_msub(y2, wr2, ymulwi2); ++ x6 = vec_add(x4, x5); ++ x7 = vec_sub(x4, x5); ++ y13 = vec_madd(y3, wr3, ymulwi3); ++ y14 = vec_msub(y3, wr3, ymulwi3); ++ ++ x8 = vec_perm(x6, x7, vcprm(0,1,s2,s3)); ++ y10 = vec_perm(y8, y9, vcprm(0,1,s2,s3)); ++ y15 = vec_perm(y13, y14, vcprm(0,1,s2,s3)); ++ ++ x9 = vec_perm(x0, x8, vcprm(0,1,s0,s2)); ++ x10 = vec_perm(x1, x8, vcprm(1,0,s3,s1)); ++ ++ y16 = vec_perm(y10, y15, vcprm(0,2,s0,s2)); ++ y17 = vec_perm(y10, y15, vcprm(3,1,s3,s1)); ++ ++ x11 = vec_add(vz0, x9); ++ x12 = vec_sub(vz0, x9); ++ x13 = vec_add(vzo1, x10); ++ x14 = vec_sub(vzo1, x10); ++ ++ y18 = vec_add(vz0plus1, y16); ++ y19 = vec_sub(vz0plus1, y16); ++ y20 = vec_add(vzo1plus1, y17); ++ y21 = vec_sub(vzo1plus1, y17); ++ ++ x15 = vec_perm(x13, x14, vcprm(0,s1,2,s3)); ++ x16 = vec_perm(x13, x14, vcprm(s0,1,s2,3)); ++ y22 = vec_perm(y20, y21, vcprm(0,s1,2,s3)); ++ y23 = vec_perm(y20, y21, vcprm(s0,1,s2,3)); ++ ++ ++ vec_st(x11, 0, &(out[0])); ++ vec_st(y18, 16, &(out[0])); ++ vec_st(x15, i1, &(out[0])); ++ vec_st(y22, i1+16, &(out[0])); ++ vec_st(x12, i2, &(out[0])); ++ vec_st(y19, i2+16, &(out[0])); ++ vec_st(x16, i3, &(out[0])); ++ vec_st(y23, i3+16, &(out[0])); ++ ++ do { ++ out += 8; ++ wre += 4; ++ wim -= 4; ++ wr0 = vec_splats(wre[0]); ++ wr1 = vec_splats(wre[1]); ++ wi0 = vec_splats(wim[0]); ++ wi1 = vec_splats(wim[-1]); ++ ++ wr2 = vec_splats(wre[2]); ++ wr3 = vec_splats(wre[3]); ++ wi2 = vec_splats(wim[-2]); ++ wi3 = vec_splats(wim[-3]); ++ ++ vzo2 = vec_ld(i2, &(out[0])); // zo2.r zo2.i z(o2+1).r z(o2+1).i ++ vzo2plus1 = vec_ld(i2+16, &(out[0])); ++ vzo3 = vec_ld(i3, &(out[0])); // zo3.r zo3.i z(o3+1).r z(o3+1).i ++ vzo3plus1 = vec_ld(i3+16, &(out[0])); ++ vz0 = vec_ld(0, &(out[0])); // z0.r z0.i z1.r z1.i ++ vz0plus1 = vec_ld(16, &(out[0])); ++ vzo1 = vec_ld(i1, &(out[0])); // zo1.r zo1.i z(o1+1).r z(o1+1).i ++ vzo1plus1 = vec_ld(i1+16, &(out[0])); ++ ++ x0 = vec_add(vzo2, vzo3); ++ x1 = vec_sub(vzo2, vzo3); ++ ++ y0 = vec_add(vzo2plus1, vzo3plus1); ++ y1 = vec_sub(vzo2plus1, vzo3plus1); ++ ++ x4 = vec_perm(x0, x1, vcprm(s1,1,s0,0)); ++ x5 = vec_perm(x0, x1, vcprm(s3,3,s2,2)); ++ x2 = vec_perm(x0, x1, vcprm(0,s0,1,s1)); ++ x3 = vec_perm(x0, x1, vcprm(2,s2,3,s3)); ++ ++ y2 = vec_perm(y0, y1, vcprm(0,s0,1,s1)); ++ y3 = vec_perm(y0, y1, vcprm(2,s2,3,s3)); ++ xmulwi0 = vec_mul(x4, wi0); ++ xmulwi1 = vec_mul(x5, wi1); ++ ++ y4 = vec_perm(y0, y1, vcprm(s1,1,s0,0)); ++ y5 = vec_perm(y0, y1, vcprm(s3,3,s2,2)); ++ ++ x8 = vec_madd(x2, wr0, xmulwi0); ++ x9 = vec_msub(x2, wr0, xmulwi0); ++ ymulwi2 = vec_mul(y4, wi2); ++ ymulwi3 = vec_mul(y5, wi3); ++ ++ x13 = vec_madd(x3, wr1, xmulwi1); ++ x14 = vec_msub(x3, wr1, xmulwi1); ++ ++ y8 = vec_madd(y2, wr2, ymulwi2); ++ y9 = vec_msub(y2, wr2, ymulwi2); ++ y13 = vec_madd(y3, wr3, ymulwi3); ++ y14 = vec_msub(y3, wr3, ymulwi3); ++ ++ x10 = vec_perm(x8, x9, vcprm(0,1,s2,s3)); ++ x15 = vec_perm(x13, x14, vcprm(0,1,s2,s3)); ++ ++ y10 = vec_perm(y8, y9, vcprm(0,1,s2,s3)); ++ y15 = vec_perm(y13, y14, vcprm(0,1,s2,s3)); ++ ++ x16 = vec_perm(x10, x15, vcprm(0,2,s0,s2)); ++ x17 = vec_perm(x10, x15, vcprm(3,1,s3,s1)); ++ ++ y16 = vec_perm(y10, y15, vcprm(0,2,s0,s2)); ++ y17 = vec_perm(y10, y15, vcprm(3,1,s3,s1)); ++ ++ x18 = vec_add(vz0, x16); ++ x19 = vec_sub(vz0, x16); ++ x20 = vec_add(vzo1, x17); ++ x21 = vec_sub(vzo1, x17); ++ ++ y18 = vec_add(vz0plus1, y16); ++ y19 = vec_sub(vz0plus1, y16); ++ y20 = vec_add(vzo1plus1, y17); ++ y21 = vec_sub(vzo1plus1, y17); ++ ++ x22 = vec_perm(x20, x21, vcprm(0,s1,2,s3)); ++ x23 = vec_perm(x20, x21, vcprm(s0,1,s2,3)); ++ ++ y22 = vec_perm(y20, y21, vcprm(0,s1,2,s3)); ++ y23 = vec_perm(y20, y21, vcprm(s0,1,s2,3)); ++ ++ vec_st(x18, 0, &(out[0])); ++ vec_st(y18, 16, &(out[0])); ++ vec_st(x22, i1, &(out[0])); ++ vec_st(y22, i1+16, &(out[0])); ++ vec_st(x19, i2, &(out[0])); ++ vec_st(y19, i2+16, &(out[0])); ++ vec_st(x23, i3, &(out[0])); ++ vec_st(y23, i3+16, &(out[0])); ++ } while (n-=2); ++} ++ ++inline static void fft2_vsx_interleave(FFTComplex *z) ++{ ++ FFTSample r1, i1; ++ ++ r1 = z[0].re - z[1].re; ++ z[0].re += z[1].re; ++ z[1].re = r1; ++ ++ i1 = z[0].im - z[1].im; ++ z[0].im += z[1].im; ++ z[1].im = i1; ++ } ++ ++inline static void fft4_vsx_interleave(FFTComplex *z) ++{ ++ vec_f a, b, c, d; ++ float* out= (float*)z; ++ a = vec_ld(0, &(out[0])); ++ b = vec_ld(byte_2complex, &(out[0])); ++ ++ c = vec_perm(a, b, vcprm(0,1,s2,s1)); ++ d = vec_perm(a, b, vcprm(2,3,s0,s3)); ++ a = vec_add(c, d); ++ b = vec_sub(c, d); ++ ++ c = vec_perm(a, b, vcprm(0,1,s0,s1)); ++ d = vec_perm(a, b, vcprm(2,3,s3,s2)); ++ ++ a = vec_add(c, d); ++ b = vec_sub(c, d); ++ vec_st(a, 0, &(out[0])); ++ vec_st(b, byte_2complex, &(out[0])); ++} ++ ++inline static void fft8_vsx_interleave(FFTComplex *z) ++{ ++ vec_f vz0, vz1, vz2, vz3; ++ vec_f x0, x1, x2, x3; ++ vec_f x4, x5, x6, x7; ++ vec_f x8, x9, x10, x11; ++ vec_f x12, x13, x14, x15; ++ vec_f x16, x17, x18, x19; ++ vec_f x20, x21, x22, x23; ++ vec_f x24, x25, x26, x27; ++ vec_f x28, x29, x30, x31; ++ vec_f x32, x33, x34; ++ ++ float* out= (float*)z; ++ vec_f vc1 = {sqrthalf, sqrthalf, sqrthalf, sqrthalf}; ++ ++ vz0 = vec_ld(0, &(out[0])); ++ vz1 = vec_ld(byte_2complex, &(out[0])); ++ vz2 = vec_ld(byte_4complex, &(out[0])); ++ vz3 = vec_ld(byte_6complex, &(out[0])); ++ ++ x0 = vec_perm(vz0, vz1, vcprm(0,1,s2,s1)); ++ x1 = vec_perm(vz0, vz1, vcprm(2,3,s0,s3)); ++ x2 = vec_perm(vz2, vz3, vcprm(2,1,s0,s1)); ++ x3 = vec_perm(vz2, vz3, vcprm(0,3,s2,s3)); ++ ++ x4 = vec_add(x0, x1); ++ x5 = vec_sub(x0, x1); ++ x6 = vec_add(x2, x3); ++ x7 = vec_sub(x2, x3); ++ ++ x8 = vec_perm(x4, x5, vcprm(0,1,s0,s1)); ++ x9 = vec_perm(x4, x5, vcprm(2,3,s3,s2)); ++ x10 = vec_perm(x6, x7, vcprm(2,1,s2,s1)); ++ x11 = vec_perm(x6, x7, vcprm(0,3,s0,s3)); ++ ++ x12 = vec_add(x8, x9); ++ x13 = vec_sub(x8, x9); ++ x14 = vec_add(x10, x11); ++ x15 = vec_sub(x10, x11); ++ x16 = vec_perm(x12, x13, vcprm(0,s0,1,s1)); ++ x17 = vec_perm(x14, x15, vcprm(0,s0,1,s1)); ++ x18 = vec_perm(x16, x17, vcprm(s0,s3,s2,s1)); ++ x19 = vec_add(x16, x18); // z0.r z2.r z0.i z2.i ++ x20 = vec_sub(x16, x18); // z4.r z6.r z4.i z6.i ++ ++ x21 = vec_perm(x12, x13, vcprm(2,s2,3,s3)); ++ x22 = vec_perm(x14, x15, vcprm(2,3,s2,s3)); ++ x23 = vec_perm(x14, x15, vcprm(3,2,s3,s2)); ++ x24 = vec_add(x22, x23); ++ x25 = vec_sub(x22, x23); ++ x26 = vec_mul( vec_perm(x24, x25, vcprm(2,s2,0,s0)), vc1); ++ ++ x27 = vec_add(x21, x26); // z1.r z7.r z1.i z3.i ++ x28 = vec_sub(x21, x26); //z5.r z3.r z5.i z7.i ++ ++ x29 = vec_perm(x19, x27, vcprm(0,2,s0,s2)); // z0.r z0.i z1.r z1.i ++ x30 = vec_perm(x19, x27, vcprm(1,3,s1,s3)); // z2.r z2.i z7.r z3.i ++ x31 = vec_perm(x20, x28, vcprm(0,2,s0,s2)); // z4.r z4.i z5.r z5.i ++ x32 = vec_perm(x20, x28, vcprm(1,3,s1,s3)); // z6.r z6.i z3.r z7.i ++ x33 = vec_perm(x30, x32, vcprm(0,1,s2,3)); // z2.r z2.i z3.r z3.i ++ x34 = vec_perm(x30, x32, vcprm(s0,s1,2,s3)); // z6.r z6.i z7.r z7.i ++ ++ vec_st(x29, 0, &(out[0])); ++ vec_st(x33, byte_2complex, &(out[0])); ++ vec_st(x31, byte_4complex, &(out[0])); ++ vec_st(x34, byte_6complex, &(out[0])); ++} ++ ++inline static void fft16_vsx_interleave(FFTComplex *z) ++{ ++ float* out= (float*)z; ++ vec_f vc0 = {sqrthalf, sqrthalf, sqrthalf, sqrthalf}; ++ vec_f vc1 = {ff_cos_16[1], ff_cos_16[1], ff_cos_16[1], ff_cos_16[1]}; ++ vec_f vc2 = {ff_cos_16[3], ff_cos_16[3], ff_cos_16[3], ff_cos_16[3]}; ++ vec_f vz0, vz1, vz2, vz3; ++ vec_f vz4, vz5, vz6, vz7; ++ vec_f x0, x1, x2, x3; ++ vec_f x4, x5, x6, x7; ++ vec_f x8, x9, x10, x11; ++ vec_f x12, x13, x14, x15; ++ vec_f x16, x17, x18, x19; ++ vec_f x20, x21, x22, x23; ++ vec_f x24, x25, x26, x27; ++ vec_f x28, x29, x30, x31; ++ vec_f x32, x33, x34, x35; ++ vec_f x36, x37, x38, x39; ++ vec_f x40, x41, x42, x43; ++ vec_f x44, x45, x46, x47; ++ vec_f x48, x49, x50, x51; ++ vec_f x52, x53, x54, x55; ++ vec_f x56, x57, x58, x59; ++ vec_f x60, x61, x62, x63; ++ vec_f x64, x65, x66, x67; ++ vec_f x68, x69, x70, x71; ++ vec_f x72, x73, x74, x75; ++ vec_f x76, x77, x78, x79; ++ vec_f x80, x81, x82, x83; ++ vec_f x84, x85, x86; ++ ++ vz0 = vec_ld(0, &(out[0])); ++ vz1 = vec_ld(byte_2complex, &(out[0])); ++ vz2 = vec_ld(byte_4complex, &(out[0])); ++ vz3 = vec_ld(byte_6complex, &(out[0])); ++ vz4 = vec_ld(byte_8complex, &(out[0])); ++ vz5 = vec_ld(byte_10complex, &(out[0])); ++ vz6 = vec_ld(byte_12complex, &(out[0])); ++ vz7 = vec_ld(byte_14complex, &(out[0])); ++ ++ x0 = vec_perm(vz0, vz1, vcprm(0,1,s2,s1)); ++ x1 = vec_perm(vz0, vz1, vcprm(2,3,s0,s3)); ++ x2 = vec_perm(vz2, vz3, vcprm(0,1,s0,s1)); ++ x3 = vec_perm(vz2, vz3, vcprm(2,3,s2,s3)); ++ ++ x4 = vec_perm(vz4, vz5, vcprm(0,1,s2,s1)); ++ x5 = vec_perm(vz4, vz5, vcprm(2,3,s0,s3)); ++ x6 = vec_perm(vz6, vz7, vcprm(0,1,s2,s1)); ++ x7 = vec_perm(vz6, vz7, vcprm(2,3,s0,s3)); ++ ++ x8 = vec_add(x0, x1); ++ x9 = vec_sub(x0, x1); ++ x10 = vec_add(x2, x3); ++ x11 = vec_sub(x2, x3); ++ ++ x12 = vec_add(x4, x5); ++ x13 = vec_sub(x4, x5); ++ x14 = vec_add(x6, x7); ++ x15 = vec_sub(x6, x7); ++ ++ x16 = vec_perm(x8, x9, vcprm(0,1,s0,s1)); ++ x17 = vec_perm(x8, x9, vcprm(2,3,s3,s2)); ++ x18 = vec_perm(x10, x11, vcprm(2,1,s1,s2)); ++ x19 = vec_perm(x10, x11, vcprm(0,3,s0,s3)); ++ x20 = vec_perm(x12, x14, vcprm(0,1,s0, s1)); ++ x21 = vec_perm(x12, x14, vcprm(2,3,s2,s3)); ++ x22 = vec_perm(x13, x15, vcprm(0,1,s0,s1)); ++ x23 = vec_perm(x13, x15, vcprm(3,2,s3,s2)); ++ ++ x24 = vec_add(x16, x17); ++ x25 = vec_sub(x16, x17); ++ x26 = vec_add(x18, x19); ++ x27 = vec_sub(x18, x19); ++ x28 = vec_add(x20, x21); ++ x29 = vec_sub(x20, x21); ++ x30 = vec_add(x22, x23); ++ x31 = vec_sub(x22, x23); ++ ++ x32 = vec_add(x24, x26); ++ x33 = vec_sub(x24, x26); ++ x34 = vec_perm(x32, x33, vcprm(0,1,s0,s1)); ++ ++ x35 = vec_perm(x28, x29, vcprm(2,1,s1,s2)); ++ x36 = vec_perm(x28, x29, vcprm(0,3,s0,s3)); ++ x37 = vec_add(x35, x36); ++ x38 = vec_sub(x35, x36); ++ x39 = vec_perm(x37, x38, vcprm(0,1,s1,s0)); ++ ++ x40 = vec_perm(x27, x38, vcprm(3,2,s2,s3)); ++ x41 = vec_perm(x26, x37, vcprm(2,3,s3,s2)); ++ x42 = vec_add(x40, x41); ++ x43 = vec_sub(x40, x41); ++ x44 = vec_mul(x42, vc0); ++ x45 = vec_mul(x43, vc0); ++ ++ x46 = vec_add(x34, x39); // z0.r z0.i z4.r z4.i ++ x47 = vec_sub(x34, x39); // z8.r z8.i z12.r z12.i ++ ++ x48 = vec_perm(x30, x31, vcprm(2,1,s1,s2)); ++ x49 = vec_perm(x30, x31, vcprm(0,3,s3,s0)); ++ x50 = vec_add(x48, x49); ++ x51 = vec_sub(x48, x49); ++ x52 = vec_mul(x50, vc1); ++ x53 = vec_mul(x50, vc2); ++ x54 = vec_mul(x51, vc1); ++ x55 = vec_mul(x51, vc2); ++ ++ x56 = vec_perm(x24, x25, vcprm(2,3,s2,s3)); ++ x57 = vec_perm(x44, x45, vcprm(0,1,s1,s0)); ++ x58 = vec_add(x56, x57); ++ x59 = vec_sub(x56, x57); ++ ++ x60 = vec_perm(x54, x55, vcprm(1,0,3,2)); ++ x61 = vec_perm(x54, x55, vcprm(s1,s0,s3,s2)); ++ x62 = vec_add(x52, x61); ++ x63 = vec_sub(x52, x61); ++ x64 = vec_add(x60, x53); ++ x65 = vec_sub(x60, x53); ++ x66 = vec_perm(x62, x64, vcprm(0,1,s3,s2)); ++ x67 = vec_perm(x63, x65, vcprm(s0,s1,3,2)); ++ ++ x68 = vec_add(x58, x66); // z1.r z1.i z3.r z3.i ++ x69 = vec_sub(x58, x66); // z9.r z9.i z11.r z11.i ++ x70 = vec_add(x59, x67); // z5.r z5.i z15.r z15.i ++ x71 = vec_sub(x59, x67); // z13.r z13.i z7.r z7.i ++ ++ x72 = vec_perm(x25, x27, vcprm(s1,s0,s2,s3)); ++ x73 = vec_add(x25, x72); ++ x74 = vec_sub(x25, x72); ++ x75 = vec_perm(x73, x74, vcprm(0,1,s0,s1)); ++ x76 = vec_perm(x44, x45, vcprm(3,2,s2,s3)); ++ x77 = vec_add(x75, x76); // z2.r z2.i z6.r z6.i ++ x78 = vec_sub(x75, x76); // z10.r z10.i z14.r z14.i ++ ++ x79 = vec_perm(x46, x68, vcprm(0,1,s0,s1)); // z0.r z0.i z1.r z1.i ++ x80 = vec_perm(x77, x68, vcprm(0,1,s2,s3)); // z2.r z2.i z3.r z3.i ++ x81 = vec_perm(x46, x70, vcprm(2,3,s0,s1)); // z4.r z4.i z5.r z5.i ++ x82 = vec_perm(x71, x77, vcprm(s2,s3,2,3)); // z6.r z6.i z7.r z7.i ++ vec_st(x79, 0, &(out[0])); ++ vec_st(x80, byte_2complex, &(out[0])); ++ vec_st(x81, byte_4complex, &(out[0])); ++ vec_st(x82, byte_6complex, &(out[0])); ++ x83 = vec_perm(x47, x69, vcprm(0,1,s0,s1)); // z8.r z8.i z9.r z9.i ++ x84 = vec_perm(x78, x69, vcprm(0,1,s2,s3)); // z10.r z10.i z11.r z11.i ++ x85 = vec_perm(x47, x71, vcprm(2,3,s0,s1)); // z12.r z12.i z13.r z13.i ++ x86 = vec_perm(x70, x78, vcprm(s2,s3,2,3)); // z14.r z14.i z15.r z15.i ++ vec_st(x83, byte_8complex, &(out[0])); ++ vec_st(x84, byte_10complex, &(out[0])); ++ vec_st(x85, byte_12complex, &(out[0])); ++ vec_st(x86, byte_14complex, &(out[0])); ++} ++ ++inline static void fft4_vsx(FFTComplex *z) ++{ ++ vec_f a, b, c, d; ++ float* out= (float*)z; ++ a = vec_ld(0, &(out[0])); ++ b = vec_ld(byte_2complex, &(out[0])); ++ ++ c = vec_perm(a, b, vcprm(0,1,s2,s1)); ++ d = vec_perm(a, b, vcprm(2,3,s0,s3)); ++ a = vec_add(c, d); ++ b = vec_sub(c, d); ++ ++ c = vec_perm(a,b, vcprm(0,s0,1,s1)); ++ d = vec_perm(a, b, vcprm(2,s3,3,s2)); ++ ++ a = vec_add(c, d); ++ b = vec_sub(c, d); ++ ++ c = vec_perm(a, b, vcprm(0,1,s0,s1)); ++ d = vec_perm(a, b, vcprm(2,3,s2,s3)); ++ ++ vec_st(c, 0, &(out[0])); ++ vec_st(d, byte_2complex, &(out[0])); ++ return; ++} ++ ++inline static void fft8_vsx(FFTComplex *z) ++{ ++ vec_f vz0, vz1, vz2, vz3; ++ vec_f vz4, vz5, vz6, vz7, vz8; ++ ++ float* out= (float*)z; ++ vec_f vc0 = {0.0, 0.0, 0.0, 0.0}; ++ vec_f vc1 = {-sqrthalf, sqrthalf, sqrthalf, -sqrthalf}; ++ vec_f vc2 = {sqrthalf, sqrthalf, sqrthalf, sqrthalf}; ++ ++ vz0 = vec_ld(0, &(out[0])); ++ vz1 = vec_ld(byte_2complex, &(out[0])); ++ vz2 = vec_ld(byte_4complex, &(out[0])); ++ vz3 = vec_ld(byte_6complex, &(out[0])); ++ ++ vz6 = vec_perm(vz2, vz3, vcprm(0,s0,1,s1)); ++ vz7 = vec_perm(vz2, vz3, vcprm(2,s2,3,s3)); ++ vz4 = vec_perm(vz0, vz1, vcprm(0,1,s2,s1)); ++ vz5 = vec_perm(vz0, vz1, vcprm(2,3,s0,s3)); ++ ++ vz2 = vec_add(vz6, vz7); ++ vz3 = vec_sub(vz6, vz7); ++ vz8 = vec_perm(vz3, vz3, vcprm(2,3,0,1)); ++ ++ vz0 = vec_add(vz4, vz5); ++ vz1 = vec_sub(vz4, vz5); ++ ++ vz3 = vec_madd(vz3, vc1, vc0); ++ vz3 = vec_madd(vz8, vc2, vz3); ++ ++ vz4 = vec_perm(vz0, vz1, vcprm(0,s0,1,s1)); ++ vz5 = vec_perm(vz0, vz1, vcprm(2,s3,3,s2)); ++ vz6 = vec_perm(vz2, vz3, vcprm(1,2,s3,s0)); ++ vz7 = vec_perm(vz2, vz3, vcprm(0,3,s2,s1)); ++ ++ vz0 = vec_add(vz4, vz5); ++ vz1 = vec_sub(vz4, vz5); ++ vz2 = vec_add(vz6, vz7); ++ vz3 = vec_sub(vz6, vz7); ++ ++ vz4 = vec_perm(vz0, vz1, vcprm(0,1,s0,s1)); ++ vz5 = vec_perm(vz0, vz1, vcprm(2,3,s2,s3)); ++ vz6 = vec_perm(vz2, vz3, vcprm(0,2,s1,s3)); ++ vz7 = vec_perm(vz2, vz3, vcprm(1,3,s0,s2)); ++ ++ ++ vz2 = vec_sub(vz4, vz6); ++ vz3 = vec_sub(vz5, vz7); ++ ++ vz0 = vec_add(vz4, vz6); ++ vz1 = vec_add(vz5, vz7); ++ ++ vec_st(vz0, 0, &(out[0])); ++ vec_st(vz1, byte_2complex, &(out[0])); ++ vec_st(vz2, byte_4complex, &(out[0])); ++ vec_st(vz3, byte_6complex, &(out[0])); ++ return; ++} ++ ++inline static void fft16_vsx(FFTComplex *z) ++{ ++ float* out= (float*)z; ++ vec_f vc0 = {0.0, 0.0, 0.0, 0.0}; ++ vec_f vc1 = {-sqrthalf, sqrthalf, sqrthalf, -sqrthalf}; ++ vec_f vc2 = {sqrthalf, sqrthalf, sqrthalf, sqrthalf}; ++ vec_f vc3 = {1.0, 0.92387953, sqrthalf, 0.38268343}; ++ vec_f vc4 = {0.0, 0.38268343, sqrthalf, 0.92387953}; ++ vec_f vc5 = {-0.0, -0.38268343, -sqrthalf, -0.92387953}; ++ ++ vec_f vz0, vz1, vz2, vz3; ++ vec_f vz4, vz5, vz6, vz7; ++ vec_f vz8, vz9, vz10, vz11; ++ vec_f vz12, vz13; ++ ++ vz0 = vec_ld(byte_8complex, &(out[0])); ++ vz1 = vec_ld(byte_10complex, &(out[0])); ++ vz2 = vec_ld(byte_12complex, &(out[0])); ++ vz3 = vec_ld(byte_14complex, &(out[0])); ++ ++ vz4 = vec_perm(vz0, vz1, vcprm(0,1,s2,s1)); ++ vz5 = vec_perm(vz0, vz1, vcprm(2,3,s0,s3)); ++ vz6 = vec_perm(vz2, vz3, vcprm(0,1,s2,s1)); ++ vz7 = vec_perm(vz2, vz3, vcprm(2,3,s0,s3)); ++ ++ vz0 = vec_add(vz4, vz5); ++ vz1= vec_sub(vz4, vz5); ++ vz2 = vec_add(vz6, vz7); ++ vz3 = vec_sub(vz6, vz7); ++ ++ vz4 = vec_perm(vz0, vz1, vcprm(0,s0,1,s1)); ++ vz5 = vec_perm(vz0, vz1, vcprm(2,s3,3,s2)); ++ vz6 = vec_perm(vz2, vz3, vcprm(0,s0,1,s1)); ++ vz7 = vec_perm(vz2, vz3, vcprm(2,s3,3,s2)); ++ ++ vz0 = vec_add(vz4, vz5); ++ vz1 = vec_sub(vz4, vz5); ++ vz2 = vec_add(vz6, vz7); ++ vz3 = vec_sub(vz6, vz7); ++ ++ vz4 = vec_perm(vz0, vz1, vcprm(0,1,s0,s1)); ++ vz5 = vec_perm(vz0, vz1, vcprm(2,3,s2,s3)); ++ ++ vz6 = vec_perm(vz2, vz3, vcprm(0,1,s0,s1)); ++ vz7 = vec_perm(vz2, vz3, vcprm(2,3,s2,s3)); ++ ++ vz0 = vec_ld(0, &(out[0])); ++ vz1 = vec_ld(byte_2complex, &(out[0])); ++ vz2 = vec_ld(byte_4complex, &(out[0])); ++ vz3 = vec_ld(byte_6complex, &(out[0])); ++ vz10 = vec_perm(vz2, vz3, vcprm(0,s0,1,s1)); ++ vz11 = vec_perm(vz2, vz3, vcprm(2,s2,3,s3)); ++ vz8 = vec_perm(vz0, vz1, vcprm(0,1,s2,s1)); ++ vz9 = vec_perm(vz0, vz1, vcprm(2,3,s0,s3)); ++ ++ vz2 = vec_add(vz10, vz11); ++ vz3 = vec_sub(vz10, vz11); ++ vz12 = vec_perm(vz3, vz3, vcprm(2,3,0,1)); ++ vz0 = vec_add(vz8, vz9); ++ vz1 = vec_sub(vz8, vz9); ++ ++ vz3 = vec_madd(vz3, vc1, vc0); ++ vz3 = vec_madd(vz12, vc2, vz3); ++ vz8 = vec_perm(vz0, vz1, vcprm(0,s0,1,s1)); ++ vz9 = vec_perm(vz0, vz1, vcprm(2,s3,3,s2)); ++ vz10 = vec_perm(vz2, vz3, vcprm(1,2,s3,s0)); ++ vz11 = vec_perm(vz2, vz3, vcprm(0,3,s2,s1)); ++ ++ vz0 = vec_add(vz8, vz9); ++ vz1 = vec_sub(vz8, vz9); ++ vz2 = vec_add(vz10, vz11); ++ vz3 = vec_sub(vz10, vz11); ++ ++ vz8 = vec_perm(vz0, vz1, vcprm(0,1,s0,s1)); ++ vz9 = vec_perm(vz0, vz1, vcprm(2,3,s2,s3)); ++ vz10 = vec_perm(vz2, vz3, vcprm(0,2,s1,s3)); ++ vz11 = vec_perm(vz2, vz3, vcprm(1,3,s0,s2)); ++ ++ vz2 = vec_sub(vz8, vz10); ++ vz3 = vec_sub(vz9, vz11); ++ vz0 = vec_add(vz8, vz10); ++ vz1 = vec_add(vz9, vz11); ++ ++ vz8 = vec_madd(vz4, vc3, vc0); ++ vz9 = vec_madd(vz5, vc3, vc0); ++ vz10 = vec_madd(vz6, vc3, vc0); ++ vz11 = vec_madd(vz7, vc3, vc0); ++ ++ vz8 = vec_madd(vz5, vc4, vz8); ++ vz9 = vec_madd(vz4, vc5, vz9); ++ vz10 = vec_madd(vz7, vc5, vz10); ++ vz11 = vec_madd(vz6, vc4, vz11); ++ ++ vz12 = vec_sub(vz10, vz8); ++ vz10 = vec_add(vz10, vz8); ++ ++ vz13 = vec_sub(vz9, vz11); ++ vz11 = vec_add(vz9, vz11); ++ ++ vz4 = vec_sub(vz0, vz10); ++ vz0 = vec_add(vz0, vz10); ++ ++ vz7= vec_sub(vz3, vz12); ++ vz3= vec_add(vz3, vz12); ++ ++ vz5 = vec_sub(vz1, vz11); ++ vz1 = vec_add(vz1, vz11); ++ ++ vz6 = vec_sub(vz2, vz13); ++ vz2 = vec_add(vz2, vz13); ++ ++ vec_st(vz0, 0, &(out[0])); ++ vec_st(vz1, byte_2complex, &(out[0])); ++ vec_st(vz2, byte_4complex, &(out[0])); ++ vec_st(vz3, byte_6complex, &(out[0])); ++ vec_st(vz4, byte_8complex, &(out[0])); ++ vec_st(vz5, byte_10complex, &(out[0])); ++ vec_st(vz6, byte_12complex, &(out[0])); ++ vec_st(vz7, byte_14complex, &(out[0])); ++ return; ++ ++} ++inline static void pass_vsx(FFTComplex * z, const FFTSample * wre, unsigned int n) ++{ ++ int o1 = n<<1; ++ int o2 = n<<2; ++ int o3 = o1+o2; ++ int i1, i2, i3; ++ FFTSample* out = (FFTSample*)z; ++ const FFTSample *wim = wre+o1; ++ vec_f v0, v1, v2, v3; ++ vec_f v4, v5, v6, v7; ++ vec_f v8, v9, v10, v11; ++ vec_f v12, v13; ++ ++ n = n-2; ++ i1 = o1*sizeof(FFTComplex); ++ i2 = o2*sizeof(FFTComplex); ++ i3 = o3*sizeof(FFTComplex); ++ ++ v8 = vec_ld(0, &(wre[0])); ++ v10 = vec_ld(0, &(wim[0])); ++ v9 = vec_ld(0, &(wim[-4])); ++ v9 = vec_perm(v9, v10, vcprm(s0,3,2,1)); ++ ++ v4 = vec_ld(i2, &(out[0])); ++ v5 = vec_ld(i2+16, &(out[0])); ++ v6 = vec_ld(i3, &(out[0])); ++ v7 = vec_ld(i3+16, &(out[0])); ++ v10 = vec_mul(v4, v8); // r2*wre ++ v11 = vec_mul(v5, v8); // i2*wre ++ v12 = vec_mul(v6, v8); // r3*wre ++ v13 = vec_mul(v7, v8); // i3*wre ++ ++ v0 = vec_ld(0, &(out[0])); // r0 ++ v3 = vec_ld(i1+16, &(out[0])); // i1 ++ v10 = vec_madd(v5, v9, v10); // r2*wim ++ v11 = vec_nmsub(v4, v9, v11); // i2*wim ++ v12 = vec_nmsub(v7, v9, v12); // r3*wim ++ v13 = vec_madd(v6, v9, v13); // i3*wim ++ ++ v1 = vec_ld(16, &(out[0])); // i0 ++ v2 = vec_ld(i1, &(out[0])); // r1 ++ v8 = vec_sub(v12, v10); ++ v12 = vec_add(v12, v10); ++ v9 = vec_sub(v11, v13); ++ v13 = vec_add(v11, v13); ++ v4 = vec_sub(v0, v12); ++ v0 = vec_add(v0, v12); ++ v7 = vec_sub(v3, v8); ++ v3 = vec_add(v3, v8); ++ ++ vec_st(v0, 0, &(out[0])); // r0 ++ vec_st(v3, i1+16, &(out[0])); // i1 ++ vec_st(v4, i2, &(out[0])); // r2 ++ vec_st(v7, i3+16, &(out[0]));// i3 ++ ++ v5 = vec_sub(v1, v13); ++ v1 = vec_add(v1, v13); ++ v6 = vec_sub(v2, v9); ++ v2 = vec_add(v2, v9); ++ ++ vec_st(v1, 16, &(out[0])); // i0 ++ vec_st(v2, i1, &(out[0])); // r1 ++ vec_st(v5, i2+16, &(out[0])); // i2 ++ vec_st(v6, i3, &(out[0])); // r3 ++ ++ do { ++ out += 8; ++ wre += 4; ++ wim -= 4; ++ ++ v8 = vec_ld(0, &(wre[0])); ++ v10 = vec_ld(0, &(wim[0])); ++ v9 = vec_ld(0, &(wim[-4])); ++ v9 = vec_perm(v9, v10, vcprm(s0,3,2,1)); ++ ++ v4 = vec_ld(i2, &(out[0])); // r2 ++ v5 = vec_ld(i2+16, &(out[0])); // i2 ++ v6 = vec_ld(i3, &(out[0])); // r3 ++ v7 = vec_ld(i3+16, &(out[0]));// i3 ++ v10 = vec_mul(v4, v8); // r2*wre ++ v11 = vec_mul(v5, v8); // i2*wre ++ v12 = vec_mul(v6, v8); // r3*wre ++ v13 = vec_mul(v7, v8); // i3*wre ++ ++ v0 = vec_ld(0, &(out[0])); // r0 ++ v3 = vec_ld(i1+16, &(out[0])); // i1 ++ v10 = vec_madd(v5, v9, v10); // r2*wim ++ v11 = vec_nmsub(v4, v9, v11); // i2*wim ++ v12 = vec_nmsub(v7, v9, v12); // r3*wim ++ v13 = vec_madd(v6, v9, v13); // i3*wim ++ ++ v1 = vec_ld(16, &(out[0])); // i0 ++ v2 = vec_ld(i1, &(out[0])); // r1 ++ v8 = vec_sub(v12, v10); ++ v12 = vec_add(v12, v10); ++ v9 = vec_sub(v11, v13); ++ v13 = vec_add(v11, v13); ++ v4 = vec_sub(v0, v12); ++ v0 = vec_add(v0, v12); ++ v7 = vec_sub(v3, v8); ++ v3 = vec_add(v3, v8); ++ ++ vec_st(v0, 0, &(out[0])); // r0 ++ vec_st(v3, i1+16, &(out[0])); // i1 ++ vec_st(v4, i2, &(out[0])); // r2 ++ vec_st(v7, i3+16, &(out[0])); // i3 ++ ++ v5 = vec_sub(v1, v13); ++ v1 = vec_add(v1, v13); ++ v6 = vec_sub(v2, v9); ++ v2 = vec_add(v2, v9); ++ ++ vec_st(v1, 16, &(out[0])); // i0 ++ vec_st(v2, i1, &(out[0])); // r1 ++ vec_st(v5, i2+16, &(out[0])); // i2 ++ vec_st(v6, i3, &(out[0])); // r3 ++ } while (n-=2); ++} ++ ++#endif ++ ++#endif /* AVCODEC_PPC_FFT_VSX_H */ +diff -Nrup ffmpeg.orig/libavcodec/ppc/hpeldsp_altivec.c ffmpeg/libavcodec/ppc/hpeldsp_altivec.c +--- ffmpeg.orig/libavcodec/ppc/hpeldsp_altivec.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/hpeldsp_altivec.c 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,386 @@ ++/* ++ * Copyright (c) 2002 Brian Foley ++ * Copyright (c) 2002 Dieter Shirley ++ * Copyright (c) 2003-2004 Romain Dolbeau ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "config.h" ++ ++#include "libavutil/attributes.h" ++#include "libavutil/cpu.h" ++#include "libavutil/ppc/cpu.h" ++#include "libavutil/ppc/util_altivec.h" ++ ++#include "libavcodec/hpeldsp.h" ++ ++#include "hpeldsp_altivec.h" ++ ++#if HAVE_ALTIVEC ++/* next one assumes that ((line_size % 16) == 0) */ ++void ff_put_pixels16_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h) ++{ ++ register vector unsigned char pixelsv1; ++ register vector unsigned char pixelsv1B; ++ register vector unsigned char pixelsv1C; ++ register vector unsigned char pixelsv1D; ++ ++ int i; ++ register ptrdiff_t line_size_2 = line_size << 1; ++ register ptrdiff_t line_size_3 = line_size + line_size_2; ++ register ptrdiff_t line_size_4 = line_size << 2; ++ ++// hand-unrolling the loop by 4 gains about 15% ++// mininum execution time goes from 74 to 60 cycles ++// it's faster than -funroll-loops, but using ++// -funroll-loops w/ this is bad - 74 cycles again. ++// all this is on a 7450, tuning for the 7450 ++ for (i = 0; i < h; i += 4) { ++ pixelsv1 = unaligned_load( 0, pixels); ++ pixelsv1B = unaligned_load(line_size, pixels); ++ pixelsv1C = unaligned_load(line_size_2, pixels); ++ pixelsv1D = unaligned_load(line_size_3, pixels); ++ VEC_ST(pixelsv1, 0, (unsigned char*)block); ++ VEC_ST(pixelsv1B, line_size, (unsigned char*)block); ++ VEC_ST(pixelsv1C, line_size_2, (unsigned char*)block); ++ VEC_ST(pixelsv1D, line_size_3, (unsigned char*)block); ++ pixels+=line_size_4; ++ block +=line_size_4; ++ } ++} ++ ++/* next one assumes that ((line_size % 16) == 0) */ ++#define op_avg(a,b) a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEUL)>>1) ) ++void ff_avg_pixels16_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h) ++{ ++ register vector unsigned char pixelsv, blockv; ++ ++ int i; ++ for (i = 0; i < h; i++) { ++ blockv = vec_ld(0, block); ++ pixelsv = VEC_LD( 0, pixels); ++ blockv = vec_avg(blockv,pixelsv); ++ vec_st(blockv, 0, (unsigned char*)block); ++ pixels+=line_size; ++ block +=line_size; ++ } ++} ++ ++/* next one assumes that ((line_size % 8) == 0) */ ++static void avg_pixels8_altivec(uint8_t * block, const uint8_t * pixels, ptrdiff_t line_size, int h) ++{ ++ register vector unsigned char pixelsv, blockv; ++ int i; ++ ++ for (i = 0; i < h; i++) { ++ /* block is 8 bytes-aligned, so we're either in the ++ left block (16 bytes-aligned) or in the right block (not) */ ++ int rightside = ((unsigned long)block & 0x0000000F); ++ ++ blockv = vec_ld(0, block); ++ pixelsv = VEC_LD( 0, pixels); ++ ++ if (rightside) { ++ pixelsv = vec_perm(blockv, pixelsv, vcprm(0,1,s0,s1)); ++ } else { ++ pixelsv = vec_perm(blockv, pixelsv, vcprm(s0,s1,2,3)); ++ } ++ ++ blockv = vec_avg(blockv, pixelsv); ++ ++ vec_st(blockv, 0, block); ++ ++ pixels += line_size; ++ block += line_size; ++ } ++} ++ ++/* next one assumes that ((line_size % 8) == 0) */ ++static void put_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h) ++{ ++ register int i; ++ register vector unsigned char pixelsv1, pixelsv2, pixelsavg; ++ register vector unsigned char blockv; ++ register vector unsigned short pixelssum1, pixelssum2, temp3; ++ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); ++ register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2); ++ ++ pixelsv1 = VEC_LD(0, pixels); ++ pixelsv2 = VEC_LD(1, pixels); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ ++ pixelssum1 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ pixelssum1 = vec_add(pixelssum1, vctwo); ++ ++ for (i = 0; i < h ; i++) { ++ int rightside = ((unsigned long)block & 0x0000000F); ++ blockv = vec_ld(0, block); ++ ++ pixelsv1 = unaligned_load(line_size, pixels); ++ pixelsv2 = unaligned_load(line_size+1, pixels); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum2 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ temp3 = vec_add(pixelssum1, pixelssum2); ++ temp3 = vec_sra(temp3, vctwo); ++ pixelssum1 = vec_add(pixelssum2, vctwo); ++ pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero); ++ ++ if (rightside) { ++ blockv = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1)); ++ } else { ++ blockv = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3)); ++ } ++ ++ vec_st(blockv, 0, block); ++ ++ block += line_size; ++ pixels += line_size; ++ } ++} ++ ++/* next one assumes that ((line_size % 8) == 0) */ ++static void put_no_rnd_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h) ++{ ++ register int i; ++ register vector unsigned char pixelsv1, pixelsv2, pixelsavg; ++ register vector unsigned char blockv; ++ register vector unsigned short pixelssum1, pixelssum2, temp3; ++ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); ++ register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1); ++ register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2); ++ ++ pixelsv1 = VEC_LD(0, pixels); ++ pixelsv2 = VEC_LD(1, pixels); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum1 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ pixelssum1 = vec_add(pixelssum1, vcone); ++ ++ for (i = 0; i < h ; i++) { ++ int rightside = ((unsigned long)block & 0x0000000F); ++ blockv = vec_ld(0, block); ++ ++ pixelsv1 = unaligned_load(line_size, pixels); ++ pixelsv2 = unaligned_load(line_size+1, pixels); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum2 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ temp3 = vec_add(pixelssum1, pixelssum2); ++ temp3 = vec_sra(temp3, vctwo); ++ pixelssum1 = vec_add(pixelssum2, vcone); ++ pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero); ++ ++ if (rightside) { ++ blockv = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1)); ++ } else { ++ blockv = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3)); ++ } ++ ++ vec_st(blockv, 0, block); ++ ++ block += line_size; ++ pixels += line_size; ++ } ++} ++ ++/* next one assumes that ((line_size % 16) == 0) */ ++static void put_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, ptrdiff_t line_size, int h) ++{ ++ register int i; ++ register vector unsigned char pixelsv1, pixelsv2, pixelsv3, pixelsv4; ++ register vector unsigned char blockv; ++ register vector unsigned short temp3, temp4, ++ pixelssum1, pixelssum2, pixelssum3, pixelssum4; ++ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); ++ register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2); ++ ++ pixelsv1 = VEC_LD(0, pixels); ++ pixelsv2 = VEC_LD(1, pixels); ++ pixelsv3 = VEC_MERGEL(vczero, pixelsv1); ++ pixelsv4 = VEC_MERGEL(vczero, pixelsv2); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum3 = vec_add((vector unsigned short)pixelsv3, ++ (vector unsigned short)pixelsv4); ++ pixelssum3 = vec_add(pixelssum3, vctwo); ++ pixelssum1 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ pixelssum1 = vec_add(pixelssum1, vctwo); ++ ++ for (i = 0; i < h ; i++) { ++ blockv = vec_ld(0, block); ++ ++ pixelsv1 = unaligned_load(line_size, pixels); ++ pixelsv2 = unaligned_load(line_size+1, pixels); ++ ++ pixelsv3 = VEC_MERGEL(vczero, pixelsv1); ++ pixelsv4 = VEC_MERGEL(vczero, pixelsv2); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum4 = vec_add((vector unsigned short)pixelsv3, ++ (vector unsigned short)pixelsv4); ++ pixelssum2 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ temp4 = vec_add(pixelssum3, pixelssum4); ++ temp4 = vec_sra(temp4, vctwo); ++ temp3 = vec_add(pixelssum1, pixelssum2); ++ temp3 = vec_sra(temp3, vctwo); ++ ++ pixelssum3 = vec_add(pixelssum4, vctwo); ++ pixelssum1 = vec_add(pixelssum2, vctwo); ++ ++ blockv = vec_packsu(temp3, temp4); ++ ++ vec_st(blockv, 0, block); ++ ++ block += line_size; ++ pixels += line_size; ++ } ++} ++ ++/* next one assumes that ((line_size % 16) == 0) */ ++static void put_no_rnd_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, ptrdiff_t line_size, int h) ++{ ++ register int i; ++ register vector unsigned char pixelsv1, pixelsv2, pixelsv3, pixelsv4; ++ register vector unsigned char blockv; ++ register vector unsigned short temp3, temp4, ++ pixelssum1, pixelssum2, pixelssum3, pixelssum4; ++ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); ++ register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1); ++ register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2); ++ ++ pixelsv1 = VEC_LD(0, pixels); ++ pixelsv2 = VEC_LD(1, pixels); ++ pixelsv3 = VEC_MERGEL(vczero, pixelsv1); ++ pixelsv4 = VEC_MERGEL(vczero, pixelsv2); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum3 = vec_add((vector unsigned short)pixelsv3, ++ (vector unsigned short)pixelsv4); ++ pixelssum3 = vec_add(pixelssum3, vcone); ++ pixelssum1 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ pixelssum1 = vec_add(pixelssum1, vcone); ++ ++ for (i = 0; i < h ; i++) { ++ pixelsv1 = unaligned_load(line_size, pixels); ++ pixelsv2 = unaligned_load(line_size+1, pixels); ++ ++ pixelsv3 = VEC_MERGEL(vczero, pixelsv1); ++ pixelsv4 = VEC_MERGEL(vczero, pixelsv2); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum4 = vec_add((vector unsigned short)pixelsv3, ++ (vector unsigned short)pixelsv4); ++ pixelssum2 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ temp4 = vec_add(pixelssum3, pixelssum4); ++ temp4 = vec_sra(temp4, vctwo); ++ temp3 = vec_add(pixelssum1, pixelssum2); ++ temp3 = vec_sra(temp3, vctwo); ++ ++ pixelssum3 = vec_add(pixelssum4, vcone); ++ pixelssum1 = vec_add(pixelssum2, vcone); ++ ++ blockv = vec_packsu(temp3, temp4); ++ ++ VEC_ST(blockv, 0, block); ++ ++ block += line_size; ++ pixels += line_size; ++ } ++} ++ ++/* next one assumes that ((line_size % 8) == 0) */ ++static void avg_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h) ++{ ++ register int i; ++ register vector unsigned char pixelsv1, pixelsv2, pixelsavg; ++ register vector unsigned char blockv, blocktemp; ++ register vector unsigned short pixelssum1, pixelssum2, temp3; ++ ++ register const vector unsigned char vczero = (const vector unsigned char) ++ vec_splat_u8(0); ++ register const vector unsigned short vctwo = (const vector unsigned short) ++ vec_splat_u16(2); ++ ++ pixelsv1 = VEC_LD(0, pixels); ++ pixelsv2 = VEC_LD(1, pixels); ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum1 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ pixelssum1 = vec_add(pixelssum1, vctwo); ++ ++ for (i = 0; i < h ; i++) { ++ int rightside = ((unsigned long)block & 0x0000000F); ++ blockv = vec_ld(0, block); ++ ++ pixelsv1 = unaligned_load(line_size, pixels); ++ pixelsv2 = unaligned_load(line_size+1, pixels); ++ ++ pixelsv1 = VEC_MERGEH(vczero, pixelsv1); ++ pixelsv2 = VEC_MERGEH(vczero, pixelsv2); ++ pixelssum2 = vec_add((vector unsigned short)pixelsv1, ++ (vector unsigned short)pixelsv2); ++ temp3 = vec_add(pixelssum1, pixelssum2); ++ temp3 = vec_sra(temp3, vctwo); ++ pixelssum1 = vec_add(pixelssum2, vctwo); ++ pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero); ++ ++ if (rightside) { ++ blocktemp = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1)); ++ } else { ++ blocktemp = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3)); ++ } ++ ++ blockv = vec_avg(blocktemp, blockv); ++ vec_st(blockv, 0, block); ++ ++ block += line_size; ++ pixels += line_size; ++ } ++} ++#endif /* HAVE_ALTIVEC */ ++ ++av_cold void ff_hpeldsp_init_ppc(HpelDSPContext *c, int flags) ++{ ++#if HAVE_ALTIVEC ++ if (!PPC_ALTIVEC(av_get_cpu_flags())) ++ return; ++ ++ c->avg_pixels_tab[0][0] = ff_avg_pixels16_altivec; ++ c->avg_pixels_tab[1][0] = avg_pixels8_altivec; ++ c->avg_pixels_tab[1][3] = avg_pixels8_xy2_altivec; ++ ++ c->put_pixels_tab[0][0] = ff_put_pixels16_altivec; ++ c->put_pixels_tab[1][3] = put_pixels8_xy2_altivec; ++ c->put_pixels_tab[0][3] = put_pixels16_xy2_altivec; ++ ++ c->put_no_rnd_pixels_tab[0][0] = ff_put_pixels16_altivec; ++ c->put_no_rnd_pixels_tab[1][3] = put_no_rnd_pixels8_xy2_altivec; ++ c->put_no_rnd_pixels_tab[0][3] = put_no_rnd_pixels16_xy2_altivec; ++#endif /* HAVE_ALTIVEC */ ++} +diff -Nrup ffmpeg.orig/libavcodec/ppc/hpeldsp_altivec.h ffmpeg/libavcodec/ppc/hpeldsp_altivec.h +--- ffmpeg.orig/libavcodec/ppc/hpeldsp_altivec.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/hpeldsp_altivec.h 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,34 @@ ++/* ++ * Copyright (c) 2002 Brian Foley ++ * Copyright (c) 2002 Dieter Shirley ++ * Copyright (c) 2003-2004 Romain Dolbeau ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_PPC_HPELDSP_ALTIVEC_H ++#define AVCODEC_PPC_HPELDSP_ALTIVEC_H ++ ++#include ++#include ++ ++void ff_avg_pixels16_altivec(uint8_t *block, const uint8_t *pixels, ++ ptrdiff_t line_size, int h); ++void ff_put_pixels16_altivec(uint8_t *block, const uint8_t *pixels, ++ ptrdiff_t line_size, int h); ++ ++#endif /* AVCODEC_PPC_HPELDSP_ALTIVEC_H */ +diff -Nrup ffmpeg.orig/libavcodec/ppc/mathops.h ffmpeg/libavcodec/ppc/mathops.h +--- ffmpeg.orig/libavcodec/ppc/mathops.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/mathops.h 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,79 @@ ++/* ++ * simple math operations ++ * Copyright (c) 2001, 2002 Fabrice Bellard ++ * Copyright (c) 2006 Michael Niedermayer et al ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_PPC_MATHOPS_H ++#define AVCODEC_PPC_MATHOPS_H ++ ++#include ++#include "config.h" ++#include "libavutil/common.h" ++ ++#if HAVE_PPC4XX ++/* signed 16x16 -> 32 multiply add accumulate */ ++#define MAC16(rt, ra, rb) \ ++ __asm__ ("maclhw %0, %2, %3" : "=r" (rt) : "0" (rt), "r" (ra), "r" (rb)); ++ ++/* signed 16x16 -> 32 multiply */ ++#define MUL16(ra, rb) \ ++ ({ int __rt; \ ++ __asm__ ("mullhw %0, %1, %2" : "=r" (__rt) : "r" (ra), "r" (rb)); \ ++ __rt; }) ++#endif ++ ++#define MULH MULH ++static inline av_const int MULH(int a, int b){ ++ int r; ++ __asm__ ("mulhw %0, %1, %2" : "=r"(r) : "r"(a), "r"(b)); ++ return r; ++} ++ ++#if !ARCH_PPC64 ++static inline av_const int64_t MAC64(int64_t d, int a, int b) ++{ ++ union { uint64_t x; unsigned hl[2]; } x = { d }; ++ int h, l; ++ __asm__ ("mullw %3, %4, %5 \n\t" ++ "mulhw %2, %4, %5 \n\t" ++ "addc %1, %1, %3 \n\t" ++ "adde %0, %0, %2 \n\t" ++ : "+r"(x.hl[0]), "+r"(x.hl[1]), "=&r"(h), "=&r"(l) ++ : "r"(a), "r"(b)); ++ return x.x; ++} ++#define MAC64(d, a, b) ((d) = MAC64(d, a, b)) ++ ++static inline av_const int64_t MLS64(int64_t d, int a, int b) ++{ ++ union { uint64_t x; unsigned hl[2]; } x = { d }; ++ int h, l; ++ __asm__ ("mullw %3, %4, %5 \n\t" ++ "mulhw %2, %4, %5 \n\t" ++ "subfc %1, %3, %1 \n\t" ++ "subfe %0, %2, %0 \n\t" ++ : "+r"(x.hl[0]), "+r"(x.hl[1]), "=&r"(h), "=&r"(l) ++ : "r"(a), "r"(b)); ++ return x.x; ++} ++#define MLS64(d, a, b) ((d) = MLS64(d, a, b)) ++#endif ++ ++#endif /* AVCODEC_PPC_MATHOPS_H */ +diff -Nrup ffmpeg.orig/libavcodec/ppc/mpegaudiodsp_altivec.c ffmpeg/libavcodec/ppc/mpegaudiodsp_altivec.c +--- ffmpeg.orig/libavcodec/ppc/mpegaudiodsp_altivec.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/mpegaudiodsp_altivec.c 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,141 @@ ++/* ++ * Altivec optimized MP3 decoding functions ++ * Copyright (c) 2010 Vitor Sessak ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "config.h" ++#include "libavutil/attributes.h" ++#include "libavutil/cpu.h" ++#include "libavutil/internal.h" ++#include "libavutil/ppc/cpu.h" ++#include "libavutil/ppc/util_altivec.h" ++#include "libavcodec/mpegaudiodsp.h" ++ ++#if HAVE_ALTIVEC ++ ++#define MACS(rt, ra, rb) rt+=(ra)*(rb) ++#define MLSS(rt, ra, rb) rt-=(ra)*(rb) ++ ++#define SUM8(op, sum, w, p) \ ++{ \ ++ op(sum, (w)[0 * 64], (p)[0 * 64]); \ ++ op(sum, (w)[1 * 64], (p)[1 * 64]); \ ++ op(sum, (w)[2 * 64], (p)[2 * 64]); \ ++ op(sum, (w)[3 * 64], (p)[3 * 64]); \ ++ op(sum, (w)[4 * 64], (p)[4 * 64]); \ ++ op(sum, (w)[5 * 64], (p)[5 * 64]); \ ++ op(sum, (w)[6 * 64], (p)[6 * 64]); \ ++ op(sum, (w)[7 * 64], (p)[7 * 64]); \ ++} ++ ++static void apply_window(const float *buf, const float *win1, ++ const float *win2, float *sum1, float *sum2, int len) ++{ ++ const vector float *win1a = (const vector float *) win1; ++ const vector float *win2a = (const vector float *) win2; ++ const vector float *bufa = (const vector float *) buf; ++ vector float *sum1a = (vector float *) sum1; ++ vector float *sum2a = (vector float *) sum2; ++ vector float av_uninit(v0), av_uninit(v4); ++ vector float v1, v2, v3; ++ ++ len = len >> 2; ++ ++#define MULT(a, b) \ ++ { \ ++ v1 = vec_ld(a, win1a); \ ++ v2 = vec_ld(b, win2a); \ ++ v3 = vec_ld(a, bufa); \ ++ v0 = vec_madd(v3, v1, v0); \ ++ v4 = vec_madd(v2, v3, v4); \ ++ } ++ ++ while (len--) { ++ v0 = vec_xor(v0, v0); ++ v4 = vec_xor(v4, v4); ++ ++ MULT( 0, 0); ++ MULT( 256, 64); ++ MULT( 512, 128); ++ MULT( 768, 192); ++ MULT(1024, 256); ++ MULT(1280, 320); ++ MULT(1536, 384); ++ MULT(1792, 448); ++ ++ vec_st(v0, 0, sum1a); ++ vec_st(v4, 0, sum2a); ++ sum1a++; ++ sum2a++; ++ win1a++; ++ win2a++; ++ bufa++; ++ } ++} ++ ++static void apply_window_mp3(float *in, float *win, int *unused, float *out, ++ ptrdiff_t incr) ++{ ++ LOCAL_ALIGNED_16(float, suma, [17]); ++ LOCAL_ALIGNED_16(float, sumb, [17]); ++ LOCAL_ALIGNED_16(float, sumc, [17]); ++ LOCAL_ALIGNED_16(float, sumd, [17]); ++ ++ float sum; ++ int j; ++ float *out2 = out + 32 * incr; ++ ++ /* copy to avoid wrap */ ++ memcpy(in + 512, in, 32 * sizeof(*in)); ++ ++ apply_window(in + 16, win , win + 512, suma, sumc, 16); ++ apply_window(in + 32, win + 48, win + 640, sumb, sumd, 16); ++ ++ SUM8(MLSS, suma[0], win + 32, in + 48); ++ ++ sumc[ 0] = 0; ++ sumb[16] = 0; ++ sumd[16] = 0; ++ ++ out[0 ] = suma[ 0]; ++ out += incr; ++ out2 -= incr; ++ for(j=1;j<16;j++) { ++ *out = suma[ j] - sumd[16-j]; ++ *out2 = -sumb[16-j] - sumc[ j]; ++ out += incr; ++ out2 -= incr; ++ } ++ ++ sum = 0; ++ SUM8(MLSS, sum, win + 16 + 32, in + 32); ++ *out = sum; ++} ++ ++#endif /* HAVE_ALTIVEC */ ++ ++av_cold void ff_mpadsp_init_ppc(MPADSPContext *s) ++{ ++#if HAVE_ALTIVEC ++ if (!PPC_ALTIVEC(av_get_cpu_flags())) ++ return; ++ ++ s->apply_window_float = apply_window_mp3; ++#endif /* HAVE_ALTIVEC */ ++} +diff -Nrup ffmpeg.orig/libavcodec/ppc/videodsp.c ffmpeg/libavcodec/ppc/videodsp.c +--- ffmpeg.orig/libavcodec/ppc/videodsp.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/videodsp.c 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,36 @@ ++/* ++ * Copyright (c) 2003-2004 Romain Dolbeau ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "libavutil/attributes.h" ++#include "libavcodec/videodsp.h" ++ ++static void prefetch_ppc(uint8_t *mem, ptrdiff_t stride, int h) ++{ ++ register const uint8_t *p = mem; ++ do { ++ __asm__ volatile ("dcbt 0,%0" : : "r" (p)); ++ p += stride; ++ } while(--h); ++} ++ ++av_cold void ff_videodsp_init_ppc(VideoDSPContext *ctx, int bpc) ++{ ++ ctx->prefetch = prefetch_ppc; ++} +diff -Nrup ffmpeg.orig/libavcodec/ppc/vorbisdsp_altivec.c ffmpeg/libavcodec/ppc/vorbisdsp_altivec.c +--- ffmpeg.orig/libavcodec/ppc/vorbisdsp_altivec.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/vorbisdsp_altivec.c 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,63 @@ ++/* ++ * Copyright (c) 2006 Luca Barbato ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "config.h" ++ ++#include "libavutil/attributes.h" ++#include "libavutil/cpu.h" ++#include "libavutil/ppc/cpu.h" ++#include "libavutil/ppc/util_altivec.h" ++ ++#include "libavcodec/vorbisdsp.h" ++ ++#if HAVE_ALTIVEC ++static void vorbis_inverse_coupling_altivec(float *mag, float *ang, ++ intptr_t blocksize) ++{ ++ int i; ++ vector float m, a; ++ vector bool int t0, t1; ++ const vector unsigned int v_31 = //XXX ++ vec_add(vec_add(vec_splat_u32(15),vec_splat_u32(15)),vec_splat_u32(1)); ++ for (i = 0; i < blocksize; i += 4) { ++ m = vec_ld(0, mag+i); ++ a = vec_ld(0, ang+i); ++ t0 = vec_cmple(m, (vector float)vec_splat_u32(0)); ++ t1 = vec_cmple(a, (vector float)vec_splat_u32(0)); ++ a = vec_xor(a, (vector float) vec_sl((vector unsigned int)t0, v_31)); ++ t0 = (vector bool int)vec_and(a, t1); ++ t1 = (vector bool int)vec_andc(a, t1); ++ a = vec_sub(m, (vector float)t1); ++ m = vec_add(m, (vector float)t0); ++ vec_stl(a, 0, ang+i); ++ vec_stl(m, 0, mag+i); ++ } ++} ++#endif /* HAVE_ALTIVEC */ ++ ++av_cold void ff_vorbisdsp_init_ppc(VorbisDSPContext *c) ++{ ++#if HAVE_ALTIVEC ++ if (!PPC_ALTIVEC(av_get_cpu_flags())) ++ return; ++ ++ c->vorbis_inverse_coupling = vorbis_inverse_coupling_altivec; ++#endif /* HAVE_ALTIVEC */ ++} +diff -Nrup ffmpeg.orig/libavcodec/ppc/vp3dsp_altivec.c ffmpeg/libavcodec/ppc/vp3dsp_altivec.c +--- ffmpeg.orig/libavcodec/ppc/vp3dsp_altivec.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/vp3dsp_altivec.c 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,204 @@ ++/* ++ * Copyright (C) 2009 David Conrad ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include ++ ++#include "config.h" ++ ++#include "libavutil/attributes.h" ++#include "libavutil/cpu.h" ++#include "libavutil/ppc/cpu.h" ++#include "libavutil/ppc/util_altivec.h" ++ ++#include "libavcodec/vp3dsp.h" ++ ++#if HAVE_ALTIVEC ++ ++static const vec_s16 constants = ++ {0, 64277, 60547, 54491, 46341, 36410, 25080, 12785}; ++#if HAVE_BIGENDIAN ++static const vec_u8 interleave_high = ++ {0, 1, 16, 17, 4, 5, 20, 21, 8, 9, 24, 25, 12, 13, 28, 29}; ++#else ++static const vec_u8 interleave_high = ++ {2, 3, 18, 19, 6, 7, 22, 23, 10, 11, 26, 27, 14, 15, 30, 31}; ++#endif ++ ++#define IDCT_START \ ++ vec_s16 A, B, C, D, Ad, Bd, Cd, Dd, E, F, G, H;\ ++ vec_s16 Ed, Gd, Add, Bdd, Fd, Hd;\ ++ vec_s16 eight = vec_splat_s16(8);\ ++ vec_u16 four = vec_splat_u16(4);\ ++\ ++ vec_s16 C1 = vec_splat(constants, 1);\ ++ vec_s16 C2 = vec_splat(constants, 2);\ ++ vec_s16 C3 = vec_splat(constants, 3);\ ++ vec_s16 C4 = vec_splat(constants, 4);\ ++ vec_s16 C5 = vec_splat(constants, 5);\ ++ vec_s16 C6 = vec_splat(constants, 6);\ ++ vec_s16 C7 = vec_splat(constants, 7);\ ++\ ++ vec_s16 b0 = vec_ld(0x00, block);\ ++ vec_s16 b1 = vec_ld(0x10, block);\ ++ vec_s16 b2 = vec_ld(0x20, block);\ ++ vec_s16 b3 = vec_ld(0x30, block);\ ++ vec_s16 b4 = vec_ld(0x40, block);\ ++ vec_s16 b5 = vec_ld(0x50, block);\ ++ vec_s16 b6 = vec_ld(0x60, block);\ ++ vec_s16 b7 = vec_ld(0x70, block); ++ ++// these functions do (a*C)>>16 ++// things are tricky because a is signed, but C unsigned. ++// M15 is used if C fits in 15 bit unsigned (C6,C7) ++// M16 is used if C requires 16 bits unsigned ++static inline vec_s16 M15(vec_s16 a, vec_s16 C) ++{ ++ return (vec_s16)vec_perm(vec_mule(a,C), vec_mulo(a,C), interleave_high); ++} ++static inline vec_s16 M16(vec_s16 a, vec_s16 C) ++{ ++ return vec_add(a, M15(a, C)); ++} ++ ++#define IDCT_1D(ADD, SHIFT)\ ++ A = vec_add(M16(b1, C1), M15(b7, C7));\ ++ B = vec_sub(M15(b1, C7), M16(b7, C1));\ ++ C = vec_add(M16(b3, C3), M16(b5, C5));\ ++ D = vec_sub(M16(b5, C3), M16(b3, C5));\ ++\ ++ Ad = M16(vec_sub(A, C), C4);\ ++ Bd = M16(vec_sub(B, D), C4);\ ++\ ++ Cd = vec_add(A, C);\ ++ Dd = vec_add(B, D);\ ++\ ++ E = ADD(M16(vec_add(b0, b4), C4));\ ++ F = ADD(M16(vec_sub(b0, b4), C4));\ ++\ ++ G = vec_add(M16(b2, C2), M15(b6, C6));\ ++ H = vec_sub(M15(b2, C6), M16(b6, C2));\ ++\ ++ Ed = vec_sub(E, G);\ ++ Gd = vec_add(E, G);\ ++\ ++ Add = vec_add(F, Ad);\ ++ Bdd = vec_sub(Bd, H);\ ++\ ++ Fd = vec_sub(F, Ad);\ ++ Hd = vec_add(Bd, H);\ ++\ ++ b0 = SHIFT(vec_add(Gd, Cd));\ ++ b7 = SHIFT(vec_sub(Gd, Cd));\ ++\ ++ b1 = SHIFT(vec_add(Add, Hd));\ ++ b2 = SHIFT(vec_sub(Add, Hd));\ ++\ ++ b3 = SHIFT(vec_add(Ed, Dd));\ ++ b4 = SHIFT(vec_sub(Ed, Dd));\ ++\ ++ b5 = SHIFT(vec_add(Fd, Bdd));\ ++ b6 = SHIFT(vec_sub(Fd, Bdd)); ++ ++#define NOP(a) a ++#define ADD8(a) vec_add(a, eight) ++#define SHIFT4(a) vec_sra(a, four) ++ ++static void vp3_idct_put_altivec(uint8_t *dst, ptrdiff_t stride, int16_t block[64]) ++{ ++ vec_u8 t; ++ IDCT_START ++ ++ // pixels are signed; so add 128*16 in addition to the normal 8 ++ vec_s16 v2048 = vec_sl(vec_splat_s16(1), vec_splat_u16(11)); ++ eight = vec_add(eight, v2048); ++ ++ IDCT_1D(NOP, NOP) ++ TRANSPOSE8(b0, b1, b2, b3, b4, b5, b6, b7); ++ IDCT_1D(ADD8, SHIFT4) ++ ++#define PUT(a)\ ++ t = vec_packsu(a, a);\ ++ vec_ste((vec_u32)t, 0, (unsigned int *)dst);\ ++ vec_ste((vec_u32)t, 4, (unsigned int *)dst); ++ ++ PUT(b0) dst += stride; ++ PUT(b1) dst += stride; ++ PUT(b2) dst += stride; ++ PUT(b3) dst += stride; ++ PUT(b4) dst += stride; ++ PUT(b5) dst += stride; ++ PUT(b6) dst += stride; ++ PUT(b7) ++ memset(block, 0, sizeof(*block) * 64); ++} ++ ++static void vp3_idct_add_altivec(uint8_t *dst, ptrdiff_t stride, int16_t block[64]) ++{ ++ LOAD_ZERO; ++ vec_u8 t, vdst; ++ vec_s16 vdst_16; ++ vec_u8 vdst_mask = vec_mergeh(vec_splat_u8(-1), vec_lvsl(0, dst)); ++ ++ IDCT_START ++ ++ IDCT_1D(NOP, NOP) ++ TRANSPOSE8(b0, b1, b2, b3, b4, b5, b6, b7); ++ IDCT_1D(ADD8, SHIFT4) ++ ++#if HAVE_BIGENDIAN ++#define GET_VDST16\ ++ vdst = vec_ld(0, dst);\ ++ vdst_16 = (vec_s16)vec_perm(vdst, zero_u8v, vdst_mask); ++#else ++#define GET_VDST16\ ++ vdst = vec_vsx_ld(0,dst);\ ++ vdst_16 = (vec_s16)vec_mergeh(vdst, zero_u8v); ++#endif ++ ++#define ADD(a)\ ++ GET_VDST16;\ ++ vdst_16 = vec_adds(a, vdst_16);\ ++ t = vec_packsu(vdst_16, vdst_16);\ ++ vec_ste((vec_u32)t, 0, (unsigned int *)dst);\ ++ vec_ste((vec_u32)t, 4, (unsigned int *)dst); ++ ++ ADD(b0) dst += stride; ++ ADD(b1) dst += stride; ++ ADD(b2) dst += stride; ++ ADD(b3) dst += stride; ++ ADD(b4) dst += stride; ++ ADD(b5) dst += stride; ++ ADD(b6) dst += stride; ++ ADD(b7) ++ memset(block, 0, sizeof(*block) * 64); ++} ++ ++#endif /* HAVE_ALTIVEC */ ++ ++av_cold void ff_vp3dsp_init_ppc(VP3DSPContext *c, int flags) ++{ ++#if HAVE_ALTIVEC ++ if (!PPC_ALTIVEC(av_get_cpu_flags())) ++ return; ++ ++ c->idct_put = vp3_idct_put_altivec; ++ c->idct_add = vp3_idct_add_altivec; ++#endif ++} +diff -Nrup ffmpeg.orig/libavcodec/ppc/vp8dsp_altivec.c ffmpeg/libavcodec/ppc/vp8dsp_altivec.c +--- ffmpeg.orig/libavcodec/ppc/vp8dsp_altivec.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavcodec/ppc/vp8dsp_altivec.c 2018-09-05 15:45:34.368754131 +0200 +@@ -0,0 +1,361 @@ ++/* ++ * VP8 compatible video decoder ++ * ++ * Copyright (C) 2010 David Conrad ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "config.h" ++ ++#include "libavutil/cpu.h" ++#include "libavutil/mem.h" ++#include "libavutil/ppc/cpu.h" ++#include "libavutil/ppc/util_altivec.h" ++ ++#include "libavcodec/vp8dsp.h" ++ ++#include "hpeldsp_altivec.h" ++ ++#if HAVE_ALTIVEC ++#define REPT4(...) { __VA_ARGS__, __VA_ARGS__, __VA_ARGS__, __VA_ARGS__ } ++ ++// h subpel filter uses msum to multiply+add 4 pixel taps at once ++static const vec_s8 h_subpel_filters_inner[7] = ++{ ++ REPT4( -6, 123, 12, -1), ++ REPT4(-11, 108, 36, -8), ++ REPT4( -9, 93, 50, -6), ++ REPT4(-16, 77, 77, -16), ++ REPT4( -6, 50, 93, -9), ++ REPT4( -8, 36, 108, -11), ++ REPT4( -1, 12, 123, -6), ++}; ++ ++// for 6tap filters, these are the outer two taps ++// The zeros mask off pixels 4-7 when filtering 0-3 ++// and vice-versa ++static const vec_s8 h_subpel_filters_outer[3] = ++{ ++ REPT4(0, 0, 2, 1), ++ REPT4(0, 0, 3, 3), ++ REPT4(0, 0, 1, 2), ++}; ++ ++#define LOAD_H_SUBPEL_FILTER(i) \ ++ vec_s8 filter_inner = h_subpel_filters_inner[i]; \ ++ vec_s8 filter_outerh = h_subpel_filters_outer[(i)>>1]; \ ++ vec_s8 filter_outerl = vec_sld(filter_outerh, filter_outerh, 2) ++ ++#if HAVE_BIGENDIAN ++#define GET_PIXHL(offset) \ ++ a = vec_ld((offset)-is6tap-1, src); \ ++ b = vec_ld((offset)-is6tap-1+15, src); \ ++ pixh = vec_perm(a, b, permh##offset); \ ++ pixl = vec_perm(a, b, perml##offset) ++ ++#define GET_OUTER(offset) outer = vec_perm(a, b, perm_6tap##offset) ++#else ++#define GET_PIXHL(offset) \ ++ a = vec_vsx_ld((offset)-is6tap-1, src); \ ++ pixh = vec_perm(a, a, perm_inner); \ ++ pixl = vec_perm(a, a, vec_add(perm_inner, vec_splat_u8(4))) ++ ++#define GET_OUTER(offset) outer = vec_perm(a, a, perm_outer) ++#endif ++ ++#define FILTER_H(dstv, off) \ ++ GET_PIXHL(off); \ ++ filth = vec_msum(filter_inner, pixh, c64); \ ++ filtl = vec_msum(filter_inner, pixl, c64); \ ++\ ++ if (is6tap) { \ ++ GET_OUTER(off); \ ++ filth = vec_msum(filter_outerh, outer, filth); \ ++ filtl = vec_msum(filter_outerl, outer, filtl); \ ++ } \ ++ if (w == 4) \ ++ filtl = filth; /* discard pixels 4-7 */ \ ++ dstv = vec_packs(filth, filtl); \ ++ dstv = vec_sra(dstv, c7) ++ ++static av_always_inline ++void put_vp8_epel_h_altivec_core(uint8_t *dst, ptrdiff_t dst_stride, ++ uint8_t *src, ptrdiff_t src_stride, ++ int h, int mx, int w, int is6tap) ++{ ++ LOAD_H_SUBPEL_FILTER(mx-1); ++#if HAVE_BIGENDIAN ++ vec_u8 align_vec0, align_vec8, permh0, permh8; ++ vec_u8 perm_6tap0, perm_6tap8, perml0, perml8; ++ vec_u8 b; ++#endif ++ vec_u8 filt, a, pixh, pixl, outer; ++ vec_s16 f16h, f16l; ++ vec_s32 filth, filtl; ++ ++ vec_u8 perm_inner6 = { 1,2,3,4, 2,3,4,5, 3,4,5,6, 4,5,6,7 }; ++ vec_u8 perm_inner4 = { 0,1,2,3, 1,2,3,4, 2,3,4,5, 3,4,5,6 }; ++ vec_u8 perm_inner = is6tap ? perm_inner6 : perm_inner4; ++ vec_u8 perm_outer = { 4,9, 0,5, 5,10, 1,6, 6,11, 2,7, 7,12, 3,8 }; ++ vec_s32 c64 = vec_sl(vec_splat_s32(1), vec_splat_u32(6)); ++ vec_u16 c7 = vec_splat_u16(7); ++ ++#if HAVE_BIGENDIAN ++ align_vec0 = vec_lvsl( -is6tap-1, src); ++ align_vec8 = vec_lvsl(8-is6tap-1, src); ++ ++ permh0 = vec_perm(align_vec0, align_vec0, perm_inner); ++ permh8 = vec_perm(align_vec8, align_vec8, perm_inner); ++ perm_inner = vec_add(perm_inner, vec_splat_u8(4)); ++ perml0 = vec_perm(align_vec0, align_vec0, perm_inner); ++ perml8 = vec_perm(align_vec8, align_vec8, perm_inner); ++ perm_6tap0 = vec_perm(align_vec0, align_vec0, perm_outer); ++ perm_6tap8 = vec_perm(align_vec8, align_vec8, perm_outer); ++#endif ++ ++ while (h --> 0) { ++ FILTER_H(f16h, 0); ++ ++ if (w == 16) { ++ FILTER_H(f16l, 8); ++ filt = vec_packsu(f16h, f16l); ++ vec_st(filt, 0, dst); ++ } else { ++ filt = vec_packsu(f16h, f16h); ++ vec_ste((vec_u32)filt, 0, (uint32_t*)dst); ++ if (w == 8) ++ vec_ste((vec_u32)filt, 4, (uint32_t*)dst); ++ } ++ src += src_stride; ++ dst += dst_stride; ++ } ++} ++ ++// v subpel filter does a simple vertical multiply + add ++static const vec_u8 v_subpel_filters[7] = ++{ ++ { 0, 6, 123, 12, 1, 0 }, ++ { 2, 11, 108, 36, 8, 1 }, ++ { 0, 9, 93, 50, 6, 0 }, ++ { 3, 16, 77, 77, 16, 3 }, ++ { 0, 6, 50, 93, 9, 0 }, ++ { 1, 8, 36, 108, 11, 2 }, ++ { 0, 1, 12, 123, 6, 0 }, ++}; ++ ++#define LOAD_V_SUBPEL_FILTER(i) \ ++ vec_u8 subpel_filter = v_subpel_filters[i]; \ ++ vec_u8 f0 = vec_splat(subpel_filter, 0); \ ++ vec_u8 f1 = vec_splat(subpel_filter, 1); \ ++ vec_u8 f2 = vec_splat(subpel_filter, 2); \ ++ vec_u8 f3 = vec_splat(subpel_filter, 3); \ ++ vec_u8 f4 = vec_splat(subpel_filter, 4); \ ++ vec_u8 f5 = vec_splat(subpel_filter, 5) ++ ++#define FILTER_V(dstv, vec_mul) \ ++ s1f = (vec_s16)vec_mul(s1, f1); \ ++ s2f = (vec_s16)vec_mul(s2, f2); \ ++ s3f = (vec_s16)vec_mul(s3, f3); \ ++ s4f = (vec_s16)vec_mul(s4, f4); \ ++ s2f = vec_subs(s2f, s1f); \ ++ s3f = vec_subs(s3f, s4f); \ ++ if (is6tap) { \ ++ s0f = (vec_s16)vec_mul(s0, f0); \ ++ s5f = (vec_s16)vec_mul(s5, f5); \ ++ s2f = vec_adds(s2f, s0f); \ ++ s3f = vec_adds(s3f, s5f); \ ++ } \ ++ dstv = vec_adds(s2f, s3f); \ ++ dstv = vec_adds(dstv, c64); \ ++ dstv = vec_sra(dstv, c7) ++ ++#if HAVE_BIGENDIAN ++#define LOAD_HL(off, s, perm) load_with_perm_vec(off, s, perm) ++#else ++#define LOAD_HL(off, s, perm) vec_mergeh(vec_vsx_ld(off,s), vec_vsx_ld(off+8,s)) ++#endif ++ ++static av_always_inline ++void put_vp8_epel_v_altivec_core(uint8_t *dst, ptrdiff_t dst_stride, ++ uint8_t *src, ptrdiff_t src_stride, ++ int h, int my, int w, int is6tap) ++{ ++ LOAD_V_SUBPEL_FILTER(my-1); ++ vec_u8 s0, s1, s2, s3, s4, s5, filt, align_vech, perm_vec, align_vecl; ++ vec_s16 s0f, s1f, s2f, s3f, s4f, s5f, f16h, f16l; ++ vec_s16 c64 = vec_sl(vec_splat_s16(1), vec_splat_u16(6)); ++ vec_u16 c7 = vec_splat_u16(7); ++ ++#if HAVE_BIGENDIAN ++ // we want pixels 0-7 to be in the even positions and 8-15 in the odd, ++ // so combine this permute with the alignment permute vector ++ align_vech = vec_lvsl(0, src); ++ align_vecl = vec_sld(align_vech, align_vech, 8); ++ if (w ==16) ++ perm_vec = vec_mergeh(align_vech, align_vecl); ++ else ++ perm_vec = vec_mergeh(align_vech, align_vech); ++#endif ++ ++ if (is6tap) ++ s0 = LOAD_HL(-2*src_stride, src, perm_vec); ++ s1 = LOAD_HL(-1*src_stride, src, perm_vec); ++ s2 = LOAD_HL( 0*src_stride, src, perm_vec); ++ s3 = LOAD_HL( 1*src_stride, src, perm_vec); ++ if (is6tap) ++ s4 = LOAD_HL( 2*src_stride, src, perm_vec); ++ ++ src += (2+is6tap)*src_stride; ++ ++ while (h --> 0) { ++ if (is6tap) ++ s5 = LOAD_HL(0, src, perm_vec); ++ else ++ s4 = LOAD_HL(0, src, perm_vec); ++ ++ FILTER_V(f16h, vec_mule); ++ ++ if (w == 16) { ++ FILTER_V(f16l, vec_mulo); ++ filt = vec_packsu(f16h, f16l); ++ vec_st(filt, 0, dst); ++ } else { ++ filt = vec_packsu(f16h, f16h); ++ if (w == 4) ++ filt = (vec_u8)vec_splat((vec_u32)filt, 0); ++ else ++ vec_ste((vec_u32)filt, 4, (uint32_t*)dst); ++ vec_ste((vec_u32)filt, 0, (uint32_t*)dst); ++ } ++ ++ if (is6tap) ++ s0 = s1; ++ s1 = s2; ++ s2 = s3; ++ s3 = s4; ++ if (is6tap) ++ s4 = s5; ++ ++ dst += dst_stride; ++ src += src_stride; ++ } ++} ++ ++#define EPEL_FUNCS(WIDTH, TAPS) \ ++static av_noinline \ ++void put_vp8_epel ## WIDTH ## _h ## TAPS ## _altivec(uint8_t *dst, ptrdiff_t dst_stride, uint8_t *src, ptrdiff_t src_stride, int h, int mx, int my) \ ++{ \ ++ put_vp8_epel_h_altivec_core(dst, dst_stride, src, src_stride, h, mx, WIDTH, TAPS == 6); \ ++} \ ++\ ++static av_noinline \ ++void put_vp8_epel ## WIDTH ## _v ## TAPS ## _altivec(uint8_t *dst, ptrdiff_t dst_stride, uint8_t *src, ptrdiff_t src_stride, int h, int mx, int my) \ ++{ \ ++ put_vp8_epel_v_altivec_core(dst, dst_stride, src, src_stride, h, my, WIDTH, TAPS == 6); \ ++} ++ ++#define EPEL_HV(WIDTH, HTAPS, VTAPS) \ ++static void put_vp8_epel ## WIDTH ## _h ## HTAPS ## v ## VTAPS ## _altivec(uint8_t *dst, ptrdiff_t dstride, uint8_t *src, ptrdiff_t sstride, int h, int mx, int my) \ ++{ \ ++ DECLARE_ALIGNED(16, uint8_t, tmp)[(2*WIDTH+5)*16]; \ ++ if (VTAPS == 6) { \ ++ put_vp8_epel ## WIDTH ## _h ## HTAPS ## _altivec(tmp, 16, src-2*sstride, sstride, h+5, mx, my); \ ++ put_vp8_epel ## WIDTH ## _v ## VTAPS ## _altivec(dst, dstride, tmp+2*16, 16, h, mx, my); \ ++ } else { \ ++ put_vp8_epel ## WIDTH ## _h ## HTAPS ## _altivec(tmp, 16, src-sstride, sstride, h+4, mx, my); \ ++ put_vp8_epel ## WIDTH ## _v ## VTAPS ## _altivec(dst, dstride, tmp+16, 16, h, mx, my); \ ++ } \ ++} ++ ++EPEL_FUNCS(16,6) ++EPEL_FUNCS(8, 6) ++EPEL_FUNCS(8, 4) ++EPEL_FUNCS(4, 6) ++EPEL_FUNCS(4, 4) ++ ++EPEL_HV(16, 6,6) ++EPEL_HV(8, 6,6) ++EPEL_HV(8, 4,6) ++EPEL_HV(8, 6,4) ++EPEL_HV(8, 4,4) ++EPEL_HV(4, 6,6) ++EPEL_HV(4, 4,6) ++EPEL_HV(4, 6,4) ++EPEL_HV(4, 4,4) ++ ++static void put_vp8_pixels16_altivec(uint8_t *dst, ptrdiff_t dstride, uint8_t *src, ptrdiff_t sstride, int h, int mx, int my) ++{ ++ register vector unsigned char perm; ++ int i; ++ register ptrdiff_t dstride2 = dstride << 1, sstride2 = sstride << 1; ++ register ptrdiff_t dstride3 = dstride2 + dstride, sstride3 = sstride + sstride2; ++ register ptrdiff_t dstride4 = dstride << 2, sstride4 = sstride << 2; ++ ++#if HAVE_BIGENDIAN ++ perm = vec_lvsl(0, src); ++#endif ++// hand-unrolling the loop by 4 gains about 15% ++// mininum execution time goes from 74 to 60 cycles ++// it's faster than -funroll-loops, but using ++// -funroll-loops w/ this is bad - 74 cycles again. ++// all this is on a 7450, tuning for the 7450 ++ for (i = 0; i < h; i += 4) { ++ vec_st(load_with_perm_vec(0, src, perm), 0, dst); ++ vec_st(load_with_perm_vec(sstride, src, perm), dstride, dst); ++ vec_st(load_with_perm_vec(sstride2, src, perm), dstride2, dst); ++ vec_st(load_with_perm_vec(sstride3, src, perm), dstride3, dst); ++ src += sstride4; ++ dst += dstride4; ++ } ++} ++ ++#endif /* HAVE_ALTIVEC */ ++ ++ ++av_cold void ff_vp78dsp_init_ppc(VP8DSPContext *c) ++{ ++#if HAVE_ALTIVEC ++ if (!PPC_ALTIVEC(av_get_cpu_flags())) ++ return; ++ ++ c->put_vp8_epel_pixels_tab[0][0][0] = put_vp8_pixels16_altivec; ++ c->put_vp8_epel_pixels_tab[0][0][2] = put_vp8_epel16_h6_altivec; ++ c->put_vp8_epel_pixels_tab[0][2][0] = put_vp8_epel16_v6_altivec; ++ c->put_vp8_epel_pixels_tab[0][2][2] = put_vp8_epel16_h6v6_altivec; ++ ++ c->put_vp8_epel_pixels_tab[1][0][2] = put_vp8_epel8_h6_altivec; ++ c->put_vp8_epel_pixels_tab[1][2][0] = put_vp8_epel8_v6_altivec; ++ c->put_vp8_epel_pixels_tab[1][0][1] = put_vp8_epel8_h4_altivec; ++ c->put_vp8_epel_pixels_tab[1][1][0] = put_vp8_epel8_v4_altivec; ++ ++ c->put_vp8_epel_pixels_tab[1][2][2] = put_vp8_epel8_h6v6_altivec; ++ c->put_vp8_epel_pixels_tab[1][1][1] = put_vp8_epel8_h4v4_altivec; ++ c->put_vp8_epel_pixels_tab[1][1][2] = put_vp8_epel8_h6v4_altivec; ++ c->put_vp8_epel_pixels_tab[1][2][1] = put_vp8_epel8_h4v6_altivec; ++ ++ c->put_vp8_epel_pixels_tab[2][0][2] = put_vp8_epel4_h6_altivec; ++ c->put_vp8_epel_pixels_tab[2][2][0] = put_vp8_epel4_v6_altivec; ++ c->put_vp8_epel_pixels_tab[2][0][1] = put_vp8_epel4_h4_altivec; ++ c->put_vp8_epel_pixels_tab[2][1][0] = put_vp8_epel4_v4_altivec; ++ ++ c->put_vp8_epel_pixels_tab[2][2][2] = put_vp8_epel4_h6v6_altivec; ++ c->put_vp8_epel_pixels_tab[2][1][1] = put_vp8_epel4_h4v4_altivec; ++ c->put_vp8_epel_pixels_tab[2][1][2] = put_vp8_epel4_h6v4_altivec; ++ c->put_vp8_epel_pixels_tab[2][2][1] = put_vp8_epel4_h4v6_altivec; ++#endif /* HAVE_ALTIVEC */ ++} +diff -Nrup ffmpeg.orig/libavutil/ppc/cpu.c ffmpeg/libavutil/ppc/cpu.c +--- ffmpeg.orig/libavutil/ppc/cpu.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/cpu.c 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,162 @@ ++/* ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "config.h" ++ ++#ifdef __APPLE__ ++#include ++#elif defined(__linux__) ++#include ++#include ++#include ++#if HAVE_UNISTD_H ++#include ++#endif ++#elif defined(__OpenBSD__) ++#include ++#include ++#include ++#elif defined(__AMIGAOS4__) ++#include ++#include ++#include ++#endif /* __APPLE__ */ ++ ++#include "libavutil/avassert.h" ++#include "libavutil/cpu.h" ++#include "libavutil/cpu_internal.h" ++ ++/** ++ * This function MAY rely on signal() or fork() in order to make sure AltiVec ++ * is present. ++ */ ++int ff_get_cpu_flags_ppc(void) ++{ ++#if HAVE_ALTIVEC ++#ifdef __AMIGAOS4__ ++ ULONG result = 0; ++ extern struct ExecIFace *IExec; ++ ++ IExec->GetCPUInfoTags(GCIT_VectorUnit, &result, TAG_DONE); ++ if (result == VECTORTYPE_ALTIVEC) ++ return AV_CPU_FLAG_ALTIVEC; ++ return 0; ++#elif defined(__APPLE__) || defined(__OpenBSD__) ++#ifdef __OpenBSD__ ++ int sels[2] = {CTL_MACHDEP, CPU_ALTIVEC}; ++#else ++ int sels[2] = {CTL_HW, HW_VECTORUNIT}; ++#endif ++ int has_vu = 0; ++ size_t len = sizeof(has_vu); ++ int err; ++ ++ err = sysctl(sels, 2, &has_vu, &len, NULL, 0); ++ ++ if (err == 0) ++ return has_vu ? AV_CPU_FLAG_ALTIVEC : 0; ++ return 0; ++#elif defined(__linux__) ++ // The linux kernel could have the altivec support disabled ++ // even if the cpu has it. ++ int i, ret = 0; ++ int fd = open("/proc/self/auxv", O_RDONLY); ++ unsigned long buf[64] = { 0 }; ++ ssize_t count; ++ ++ if (fd < 0) ++ return 0; ++ ++ while ((count = read(fd, buf, sizeof(buf))) > 0) { ++ for (i = 0; i < count / sizeof(*buf); i += 2) { ++ if (buf[i] == AT_NULL) ++ goto out; ++ if (buf[i] == AT_HWCAP) { ++ if (buf[i + 1] & PPC_FEATURE_HAS_ALTIVEC) ++ ret = AV_CPU_FLAG_ALTIVEC; ++#ifdef PPC_FEATURE_HAS_VSX ++ if (buf[i + 1] & PPC_FEATURE_HAS_VSX) ++ ret |= AV_CPU_FLAG_VSX; ++#endif ++#ifdef PPC_FEATURE_ARCH_2_07 ++ if (buf[i + 1] & PPC_FEATURE_HAS_POWER8) ++ ret |= AV_CPU_FLAG_POWER8; ++#endif ++ if (ret & AV_CPU_FLAG_VSX) ++ av_assert0(ret & AV_CPU_FLAG_ALTIVEC); ++ goto out; ++ } ++ } ++ } ++ ++out: ++ close(fd); ++ return ret; ++#elif CONFIG_RUNTIME_CPUDETECT && defined(__linux__) ++#define PVR_G4_7400 0x000C ++#define PVR_G5_970 0x0039 ++#define PVR_G5_970FX 0x003C ++#define PVR_G5_970MP 0x0044 ++#define PVR_G5_970GX 0x0045 ++#define PVR_POWER6 0x003E ++#define PVR_POWER7 0x003F ++#define PVR_POWER8 0x004B ++#define PVR_CELL_PPU 0x0070 ++ int ret = 0; ++ int proc_ver; ++ // Support of mfspr PVR emulation added in Linux 2.6.17. ++ __asm__ volatile("mfspr %0, 287" : "=r" (proc_ver)); ++ proc_ver >>= 16; ++ if (proc_ver & 0x8000 || ++ proc_ver == PVR_G4_7400 || ++ proc_ver == PVR_G5_970 || ++ proc_ver == PVR_G5_970FX || ++ proc_ver == PVR_G5_970MP || ++ proc_ver == PVR_G5_970GX || ++ proc_ver == PVR_POWER6 || ++ proc_ver == PVR_POWER7 || ++ proc_ver == PVR_POWER8 || ++ proc_ver == PVR_CELL_PPU) ++ ret = AV_CPU_FLAG_ALTIVEC; ++ if (proc_ver == PVR_POWER7 || ++ proc_ver == PVR_POWER8) ++ ret |= AV_CPU_FLAG_VSX; ++ if (proc_ver == PVR_POWER8) ++ ret |= AV_CPU_FLAG_POWER8; ++ ++ return ret; ++#else ++ // Since we were compiled for AltiVec, just assume we have it ++ // until someone comes up with a proper way (not involving signal hacks). ++ return AV_CPU_FLAG_ALTIVEC; ++#endif /* __AMIGAOS4__ */ ++#endif /* HAVE_ALTIVEC */ ++ return 0; ++} ++ ++size_t ff_get_cpu_max_align_ppc(void) ++{ ++ int flags = av_get_cpu_flags(); ++ ++ if (flags & (AV_CPU_FLAG_ALTIVEC | ++ AV_CPU_FLAG_VSX | ++ AV_CPU_FLAG_POWER8)) ++ return 16; ++ ++ return 8; ++} +diff -Nrup ffmpeg.orig/libavutil/ppc/cpu.h ffmpeg/libavutil/ppc/cpu.h +--- ffmpeg.orig/libavutil/ppc/cpu.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/cpu.h 2018-09-07 13:32:42.161848338 +0200 +@@ -0,0 +1,30 @@ ++/* ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVUTIL_PPC_CPU_H ++#define AVUTIL_PPC_CPU_H ++ ++#include "config.h" ++#include "libavutil/cpu.h" ++#include "libavutil/cpu_internal.h" ++ ++#define PPC_ALTIVEC(flags) CPUEXT(flags, ALTIVEC) ++#define PPC_VSX(flags) CPUEXT(flags, VSX) ++#define PPC_POWER8(flags) CPUEXT(flags, POWER8) ++ ++#endif /* AVUTIL_PPC_CPU_H */ +diff -Nrup ffmpeg.orig/libavutil/ppc/float_dsp_altivec.c ffmpeg/libavutil/ppc/float_dsp_altivec.c +--- ffmpeg.orig/libavutil/ppc/float_dsp_altivec.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/float_dsp_altivec.c 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,122 @@ ++/* ++ * Copyright (c) 2006 Luca Barbato ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "util_altivec.h" ++#include "float_dsp_altivec.h" ++ ++void ff_vector_fmul_altivec(float *dst, const float *src0, const float *src1, ++ int len) ++{ ++ int i; ++ vec_f d0, d1, s, zero = (vec_f)vec_splat_u32(0); ++ for (i = 0; i < len - 7; i += 8) { ++ d0 = vec_ld( 0, src0 + i); ++ s = vec_ld( 0, src1 + i); ++ d1 = vec_ld(16, src0 + i); ++ d0 = vec_madd(d0, s, zero); ++ d1 = vec_madd(d1, vec_ld(16, src1 + i), zero); ++ vec_st(d0, 0, dst + i); ++ vec_st(d1, 16, dst + i); ++ } ++} ++ ++void ff_vector_fmul_window_altivec(float *dst, const float *src0, ++ const float *src1, const float *win, int len) ++{ ++ vec_f zero, t0, t1, s0, s1, wi, wj; ++ const vec_u8 reverse = vcprm(3, 2, 1, 0); ++ int i, j; ++ ++ dst += len; ++ win += len; ++ src0 += len; ++ ++ zero = (vec_f)vec_splat_u32(0); ++ ++ for (i = -len * 4, j = len * 4 - 16; i < 0; i += 16, j -= 16) { ++ s0 = vec_ld(i, src0); ++ s1 = vec_ld(j, src1); ++ wi = vec_ld(i, win); ++ wj = vec_ld(j, win); ++ ++ s1 = vec_perm(s1, s1, reverse); ++ wj = vec_perm(wj, wj, reverse); ++ ++ t0 = vec_madd(s0, wj, zero); ++ t0 = vec_nmsub(s1, wi, t0); ++ t1 = vec_madd(s0, wi, zero); ++ t1 = vec_madd(s1, wj, t1); ++ t1 = vec_perm(t1, t1, reverse); ++ ++ vec_st(t0, i, dst); ++ vec_st(t1, j, dst); ++ } ++} ++ ++void ff_vector_fmul_add_altivec(float *dst, const float *src0, ++ const float *src1, const float *src2, ++ int len) ++{ ++ int i; ++ vec_f d, ss0, ss1, ss2, t0, t1, edges; ++ ++ for (i = 0; i < len - 3; i += 4) { ++ t0 = vec_ld(0, dst + i); ++ t1 = vec_ld(15, dst + i); ++ ss0 = vec_ld(0, src0 + i); ++ ss1 = vec_ld(0, src1 + i); ++ ss2 = vec_ld(0, src2 + i); ++ edges = vec_perm(t1, t0, vcprm(0, 1, 2, 3)); ++ d = vec_madd(ss0, ss1, ss2); ++ t1 = vec_perm(d, edges, vcprm(s0,s1,s2,s3)); ++ t0 = vec_perm(edges, d, vcprm(s0,s1,s2,s3)); ++ vec_st(t1, 15, dst + i); ++ vec_st(t0, 0, dst + i); ++ } ++} ++ ++void ff_vector_fmul_reverse_altivec(float *dst, const float *src0, ++ const float *src1, int len) ++{ ++ int i; ++ vec_f d, s0, s1, h0, l0, s2, s3; ++ vec_f zero = (vec_f)vec_splat_u32(0); ++ ++ src1 += len-4; ++ for(i = 0; i < len - 7; i += 8) { ++ s1 = vec_ld(0, src1 - i); // [a,b,c,d] ++ s0 = vec_ld(0, src0 + i); ++ l0 = vec_mergel(s1, s1); // [c,c,d,d] ++ s3 = vec_ld(-16, src1 - i); ++ h0 = vec_mergeh(s1, s1); // [a,a,b,b] ++ s2 = vec_ld(16, src0 + i); ++ s1 = vec_mergeh(vec_mergel(l0, h0), // [d,b,d,b] ++ vec_mergeh(l0, h0)); // [c,a,c,a] ++ // [d,c,b,a] ++ l0 = vec_mergel(s3, s3); ++ d = vec_madd(s0, s1, zero); ++ h0 = vec_mergeh(s3, s3); ++ vec_st(d, 0, dst + i); ++ s3 = vec_mergeh(vec_mergel(l0, h0), ++ vec_mergeh(l0, h0)); ++ d = vec_madd(s2, s3, zero); ++ vec_st(d, 16, dst + i); ++ } ++} +diff -Nrup ffmpeg.orig/libavutil/ppc/float_dsp_altivec.h ffmpeg/libavutil/ppc/float_dsp_altivec.h +--- ffmpeg.orig/libavutil/ppc/float_dsp_altivec.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/float_dsp_altivec.h 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,38 @@ ++/* ++ * Copyright (c) 2006 Luca Barbato ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVUTIL_PPC_FLOAT_DSP_ALTIVEC_H ++#define AVUTIL_PPC_FLOAT_DSP_ALTIVEC_H ++ ++void ff_vector_fmul_altivec(float *dst, const float *src0, ++ const float *src1, int len); ++ ++void ff_vector_fmul_window_altivec(float *dst, const float *src0, ++ const float *src1, const float *win, ++ int len); ++ ++void ff_vector_fmul_add_altivec(float *dst, const float *src0, ++ const float *src1, const float *src2, ++ int len); ++ ++void ff_vector_fmul_reverse_altivec(float *dst, const float *src0, ++ const float *src1, int len); ++ ++#endif /* AVUTIL_PPC_FLOAT_DSP_ALTIVEC_H */ +diff -Nrup ffmpeg.orig/libavutil/ppc/float_dsp_init.c ffmpeg/libavutil/ppc/float_dsp_init.c +--- ffmpeg.orig/libavutil/ppc/float_dsp_init.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/float_dsp_init.c 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,52 @@ ++/* ++ * Copyright (c) 2006 Luca Barbato ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "config.h" ++#include "libavutil/attributes.h" ++#include "libavutil/cpu.h" ++#include "libavutil/float_dsp.h" ++#include "libavutil/ppc/cpu.h" ++#include "float_dsp_altivec.h" ++#include "float_dsp_vsx.h" ++ ++av_cold void ff_float_dsp_init_ppc(AVFloatDSPContext *fdsp, int bit_exact) ++{ ++ if (PPC_ALTIVEC(av_get_cpu_flags())) { ++ fdsp->vector_fmul = ff_vector_fmul_altivec; ++ fdsp->vector_fmul_add = ff_vector_fmul_add_altivec; ++ fdsp->vector_fmul_reverse = ff_vector_fmul_reverse_altivec; ++ ++ if (!bit_exact) { ++ fdsp->vector_fmul_window = ff_vector_fmul_window_altivec; ++ } ++ } ++ ++ // The disabled function below are near identical to altivec and have ++ // been disabled to reduce code duplication ++ if (PPC_VSX(av_get_cpu_flags())) { ++// fdsp->vector_fmul = ff_vector_fmul_vsx; ++ fdsp->vector_fmul_add = ff_vector_fmul_add_vsx; ++// fdsp->vector_fmul_reverse = ff_vector_fmul_reverse_vsx; ++ ++// if (!bit_exact) { ++// fdsp->vector_fmul_window = ff_vector_fmul_window_vsx; ++// } ++ } ++} +diff -Nrup ffmpeg.orig/libavutil/ppc/float_dsp_vsx.c ffmpeg/libavutil/ppc/float_dsp_vsx.c +--- ffmpeg.orig/libavutil/ppc/float_dsp_vsx.c 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/float_dsp_vsx.c 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,117 @@ ++/* ++ * Copyright (c) 2015 Luca Barbato ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "util_altivec.h" ++#include "float_dsp_vsx.h" ++ ++void ff_vector_fmul_vsx(float *dst, ++ const float *src0, const float *src1, ++ int len) ++{ ++ int i; ++ vec_f d0, d1, zero = (vec_f)vec_splat_u32(0); ++ for (i = 0; i < len - 7; i += 8) { ++ d0 = vec_vsx_ld( 0, src0 + i); ++ d1 = vec_vsx_ld(16, src0 + i); ++ d0 = vec_madd(d0, vec_vsx_ld( 0, src1 + i), zero); ++ d1 = vec_madd(d1, vec_vsx_ld(16, src1 + i), zero); ++ vec_vsx_st(d0, 0, dst + i); ++ vec_vsx_st(d1, 16, dst + i); ++ } ++} ++ ++void ff_vector_fmul_window_vsx(float *dst, const float *src0, ++ const float *src1, const float *win, ++ int len) ++{ ++ vec_f zero, t0, t1, s0, s1, wi, wj; ++ const vec_u8 reverse = vcprm(3, 2, 1, 0); ++ int i, j; ++ ++ dst += len; ++ win += len; ++ src0 += len; ++ ++ zero = (vec_f)vec_splat_u32(0); ++ ++ for (i = -len * 4, j = len * 4 - 16; i < 0; i += 16, j -= 16) { ++ s0 = vec_vsx_ld(i, src0); ++ s1 = vec_vsx_ld(j, src1); ++ wi = vec_vsx_ld(i, win); ++ wj = vec_vsx_ld(j, win); ++ ++ s1 = vec_perm(s1, s1, reverse); ++ wj = vec_perm(wj, wj, reverse); ++ ++ t0 = vec_madd(s0, wj, zero); ++ t0 = vec_nmsub(s1, wi, t0); ++ t1 = vec_madd(s0, wi, zero); ++ t1 = vec_madd(s1, wj, t1); ++ t1 = vec_perm(t1, t1, reverse); ++ ++ vec_vsx_st(t0, i, dst); ++ vec_vsx_st(t1, j, dst); ++ } ++} ++ ++void ff_vector_fmul_add_vsx(float *dst, const float *src0, ++ const float *src1, const float *src2, ++ int len) ++{ ++ int i; ++ vec_f d, s0, s1, s2; ++ ++ for (i = 0; i < len - 3; i += 4) { ++ s0 = vec_vsx_ld(0, src0 + i); ++ s1 = vec_vsx_ld(0, src1 + i); ++ s2 = vec_vsx_ld(0, src2 + i); ++ d = vec_madd(s0, s1, s2); ++ vec_vsx_st(d, 0, dst + i); ++ } ++} ++ ++void ff_vector_fmul_reverse_vsx(float *dst, const float *src0, ++ const float *src1, int len) ++{ ++ int i; ++ vec_f d, s0, s1, h0, l0, s2, s3; ++ vec_f zero = (vec_f)vec_splat_u32(0); ++ ++ src1 += len - 4; ++ for (i = 0; i < len - 7; i += 8) { ++ s1 = vec_vsx_ld(0, src1 - i); // [a,b,c,d] ++ s0 = vec_vsx_ld(0, src0 + i); ++ l0 = vec_mergel(s1, s1); // [c,c,d,d] ++ s3 = vec_vsx_ld(-16, src1 - i); ++ h0 = vec_mergeh(s1, s1); // [a,a,b,b] ++ s2 = vec_vsx_ld(16, src0 + i); ++ s1 = vec_mergeh(vec_mergel(l0, h0), // [d,b,d,b] ++ vec_mergeh(l0, h0)); // [c,a,c,a] ++ // [d,c,b,a] ++ l0 = vec_mergel(s3, s3); ++ d = vec_madd(s0, s1, zero); ++ h0 = vec_mergeh(s3, s3); ++ vec_vsx_st(d, 0, dst + i); ++ s3 = vec_mergeh(vec_mergel(l0, h0), ++ vec_mergeh(l0, h0)); ++ d = vec_madd(s2, s3, zero); ++ vec_vsx_st(d, 16, dst + i); ++ } ++} +diff -Nrup ffmpeg.orig/libavutil/ppc/float_dsp_vsx.h ffmpeg/libavutil/ppc/float_dsp_vsx.h +--- ffmpeg.orig/libavutil/ppc/float_dsp_vsx.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/float_dsp_vsx.h 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,38 @@ ++/* ++ * Copyright (c) 2015 Luca Barbato ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVUTIL_PPC_FLOAT_DSP_VSX_H ++#define AVUTIL_PPC_FLOAT_DSP_VSX_H ++ ++void ff_vector_fmul_vsx(float *dst, const float *src0, ++ const float *src1, int len); ++ ++void ff_vector_fmul_window_vsx(float *dst, const float *src0, ++ const float *src1, const float *win, ++ int len); ++ ++void ff_vector_fmul_add_vsx(float *dst, const float *src0, ++ const float *src1, const float *src2, ++ int len); ++ ++void ff_vector_fmul_reverse_vsx(float *dst, const float *src0, ++ const float *src1, int len); ++ ++#endif /* AVUTIL_PPC_FLOAT_DSP_VSX_H */ +diff -Nrup ffmpeg.orig/libavutil/ppc/intreadwrite.h ffmpeg/libavutil/ppc/intreadwrite.h +--- ffmpeg.orig/libavutil/ppc/intreadwrite.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/intreadwrite.h 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,110 @@ ++/* ++ * Copyright (c) 2008 Mans Rullgard ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVUTIL_PPC_INTREADWRITE_H ++#define AVUTIL_PPC_INTREADWRITE_H ++ ++#include ++#include "config.h" ++ ++#if HAVE_XFORM_ASM ++ ++#if HAVE_BIGENDIAN ++#define AV_RL16 av_read_bswap16 ++#define AV_WL16 av_write_bswap16 ++#define AV_RL32 av_read_bswap32 ++#define AV_WL32 av_write_bswap32 ++#define AV_RL64 av_read_bswap64 ++#define AV_WL64 av_write_bswap64 ++ ++#else ++#define AV_RB16 av_read_bswap16 ++#define AV_WB16 av_write_bswap16 ++#define AV_RB32 av_read_bswap32 ++#define AV_WB32 av_write_bswap32 ++#define AV_RB64 av_read_bswap64 ++#define AV_WB64 av_write_bswap64 ++ ++#endif ++ ++static av_always_inline uint16_t av_read_bswap16(const void *p) ++{ ++ uint16_t v; ++ __asm__ ("lhbrx %0, %y1" : "=r"(v) : "Z"(*(const uint16_t*)p)); ++ return v; ++} ++ ++static av_always_inline void av_write_bswap16(void *p, uint16_t v) ++{ ++ __asm__ ("sthbrx %1, %y0" : "=Z"(*(uint16_t*)p) : "r"(v)); ++} ++ ++static av_always_inline uint32_t av_read_bswap32(const void *p) ++{ ++ uint32_t v; ++ __asm__ ("lwbrx %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p)); ++ return v; ++} ++ ++static av_always_inline void av_write_bswap32(void *p, uint32_t v) ++{ ++ __asm__ ("stwbrx %1, %y0" : "=Z"(*(uint32_t*)p) : "r"(v)); ++} ++ ++#if HAVE_LDBRX ++ ++static av_always_inline uint64_t av_read_bswap64(const void *p) ++{ ++ uint64_t v; ++ __asm__ ("ldbrx %0, %y1" : "=r"(v) : "Z"(*(const uint64_t*)p)); ++ return v; ++} ++ ++static av_always_inline void av_write_bswap64(void *p, uint64_t v) ++{ ++ __asm__ ("stdbrx %1, %y0" : "=Z"(*(uint64_t*)p) : "r"(v)); ++} ++ ++#else ++ ++static av_always_inline uint64_t av_read_bswap64(const void *p) ++{ ++ union { uint64_t v; uint32_t hl[2]; } v; ++ __asm__ ("lwbrx %0, %y2 \n\t" ++ "lwbrx %1, %y3 \n\t" ++ : "=&r"(v.hl[1]), "=r"(v.hl[0]) ++ : "Z"(*(const uint32_t*)p), "Z"(*((const uint32_t*)p+1))); ++ return v.v; ++} ++ ++static av_always_inline void av_write_bswap64(void *p, uint64_t v) ++{ ++ union { uint64_t v; uint32_t hl[2]; } vv = { v }; ++ __asm__ ("stwbrx %2, %y0 \n\t" ++ "stwbrx %3, %y1 \n\t" ++ : "=Z"(*(uint32_t*)p), "=Z"(*((uint32_t*)p+1)) ++ : "r"(vv.hl[1]), "r"(vv.hl[0])); ++} ++ ++#endif /* HAVE_LDBRX */ ++ ++#endif /* HAVE_XFORM_ASM */ ++ ++#endif /* AVUTIL_PPC_INTREADWRITE_H */ +diff -Nrup ffmpeg.orig/libavutil/ppc/timer.h ffmpeg/libavutil/ppc/timer.h +--- ffmpeg.orig/libavutil/ppc/timer.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/timer.h 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,48 @@ ++/* ++ * Copyright (c) 2005 Luca Barbato ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVUTIL_PPC_TIMER_H ++#define AVUTIL_PPC_TIMER_H ++ ++#include ++ ++#include "config.h" ++ ++#define AV_READ_TIME read_time ++ ++static inline uint64_t read_time(void) ++{ ++ uint32_t tbu, tbl, temp; ++ ++ /* from section 2.2.1 of the 32-bit PowerPC PEM */ ++ __asm__ volatile( ++ "mftbu %2\n" ++ "mftb %0\n" ++ "mftbu %1\n" ++ "cmpw %2,%1\n" ++ "bne $-0x10\n" ++ : "=r"(tbl), "=r"(tbu), "=r"(temp) ++ : ++ : "cc"); ++ ++ return (((uint64_t)tbu)<<32) | (uint64_t)tbl; ++} ++ ++#endif /* AVUTIL_PPC_TIMER_H */ +diff -Nrup ffmpeg.orig/libavutil/ppc/util_altivec.h ffmpeg/libavutil/ppc/util_altivec.h +--- ffmpeg.orig/libavutil/ppc/util_altivec.h 1970-01-01 01:00:00.000000000 +0100 ++++ ffmpeg/libavutil/ppc/util_altivec.h 2018-09-05 15:45:34.938766223 +0200 +@@ -0,0 +1,195 @@ ++/* ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++/** ++ * @file ++ * Contains misc utility macros and inline functions ++ */ ++ ++#ifndef AVUTIL_PPC_UTIL_ALTIVEC_H ++#define AVUTIL_PPC_UTIL_ALTIVEC_H ++ ++#include ++ ++#include "config.h" ++ ++/*********************************************************************** ++ * Vector types ++ **********************************************************************/ ++#define vec_u8 vector unsigned char ++#define vec_s8 vector signed char ++#define vec_u16 vector unsigned short ++#define vec_s16 vector signed short ++#define vec_u32 vector unsigned int ++#define vec_s32 vector signed int ++#define vec_f vector float ++ ++/*********************************************************************** ++ * Null vector ++ **********************************************************************/ ++#define LOAD_ZERO const vec_u8 zerov = vec_splat_u8( 0 ) ++ ++#define zero_u8v (vec_u8) zerov ++#define zero_s8v (vec_s8) zerov ++#define zero_u16v (vec_u16) zerov ++#define zero_s16v (vec_s16) zerov ++#define zero_u32v (vec_u32) zerov ++#define zero_s32v (vec_s32) zerov ++ ++#if HAVE_ALTIVEC ++#include ++ ++// used to build registers permutation vectors (vcprm) ++// the 's' are for words in the _s_econd vector ++#define WORD_0 0x00,0x01,0x02,0x03 ++#define WORD_1 0x04,0x05,0x06,0x07 ++#define WORD_2 0x08,0x09,0x0a,0x0b ++#define WORD_3 0x0c,0x0d,0x0e,0x0f ++#define WORD_s0 0x10,0x11,0x12,0x13 ++#define WORD_s1 0x14,0x15,0x16,0x17 ++#define WORD_s2 0x18,0x19,0x1a,0x1b ++#define WORD_s3 0x1c,0x1d,0x1e,0x1f ++#define vcprm(a,b,c,d) (const vec_u8){WORD_ ## a, WORD_ ## b, WORD_ ## c, WORD_ ## d} ++ ++#define SWP_W2S0 0x02,0x03,0x00,0x01 ++#define SWP_W2S1 0x06,0x07,0x04,0x05 ++#define SWP_W2S2 0x0a,0x0b,0x08,0x09 ++#define SWP_W2S3 0x0e,0x0f,0x0c,0x0d ++#define SWP_W2Ss0 0x12,0x13,0x10,0x11 ++#define SWP_W2Ss1 0x16,0x17,0x14,0x15 ++#define SWP_W2Ss2 0x1a,0x1b,0x18,0x19 ++#define SWP_W2Ss3 0x1e,0x1f,0x1c,0x1d ++#define vcswapi2s(a,b,c,d) (const vector unsigned char){SWP_W2S ## a, SWP_W2S ## b, SWP_W2S ## c, SWP_W2S ## d} ++ ++#define vcswapc() \ ++ (const vector unsigned char){0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00} ++ ++ ++// Transpose 8x8 matrix of 16-bit elements (in-place) ++#define TRANSPOSE8(a,b,c,d,e,f,g,h) \ ++do { \ ++ vec_s16 A1, B1, C1, D1, E1, F1, G1, H1; \ ++ vec_s16 A2, B2, C2, D2, E2, F2, G2, H2; \ ++ \ ++ A1 = vec_mergeh (a, e); \ ++ B1 = vec_mergel (a, e); \ ++ C1 = vec_mergeh (b, f); \ ++ D1 = vec_mergel (b, f); \ ++ E1 = vec_mergeh (c, g); \ ++ F1 = vec_mergel (c, g); \ ++ G1 = vec_mergeh (d, h); \ ++ H1 = vec_mergel (d, h); \ ++ \ ++ A2 = vec_mergeh (A1, E1); \ ++ B2 = vec_mergel (A1, E1); \ ++ C2 = vec_mergeh (B1, F1); \ ++ D2 = vec_mergel (B1, F1); \ ++ E2 = vec_mergeh (C1, G1); \ ++ F2 = vec_mergel (C1, G1); \ ++ G2 = vec_mergeh (D1, H1); \ ++ H2 = vec_mergel (D1, H1); \ ++ \ ++ a = vec_mergeh (A2, E2); \ ++ b = vec_mergel (A2, E2); \ ++ c = vec_mergeh (B2, F2); \ ++ d = vec_mergel (B2, F2); \ ++ e = vec_mergeh (C2, G2); \ ++ f = vec_mergel (C2, G2); \ ++ g = vec_mergeh (D2, H2); \ ++ h = vec_mergel (D2, H2); \ ++} while (0) ++ ++ ++#if HAVE_BIGENDIAN ++#define VEC_LD(offset,b) \ ++ vec_perm(vec_ld(offset, b), vec_ld((offset)+15, b), vec_lvsl(offset, b)) ++#else ++#define VEC_LD(offset,b) \ ++ vec_vsx_ld(offset, b) ++#endif ++ ++/** @brief loads unaligned vector @a *src with offset @a offset ++ and returns it */ ++#if HAVE_BIGENDIAN ++static inline vec_u8 unaligned_load(int offset, const uint8_t *src) ++{ ++ register vec_u8 first = vec_ld(offset, src); ++ register vec_u8 second = vec_ld(offset + 15, src); ++ register vec_u8 mask = vec_lvsl(offset, src); ++ return vec_perm(first, second, mask); ++} ++static inline vec_u8 load_with_perm_vec(int offset, const uint8_t *src, vec_u8 perm_vec) ++{ ++ vec_u8 a = vec_ld(offset, src); ++ vec_u8 b = vec_ld(offset + 15, src); ++ return vec_perm(a, b, perm_vec); ++} ++#else ++#define unaligned_load(a,b) VEC_LD(a,b) ++#define load_with_perm_vec(a,b,c) VEC_LD(a,b) ++#endif ++ ++ ++/** ++ * loads vector known misalignment ++ * @param perm_vec the align permute vector to combine the two loads from lvsl ++ */ ++ ++#define vec_unaligned_load(b) VEC_LD(0, b) ++ ++#if HAVE_BIGENDIAN ++#define VEC_MERGEH(a, b) vec_mergeh(a, b) ++#define VEC_MERGEL(a, b) vec_mergel(a, b) ++#else ++#define VEC_MERGEH(a, b) vec_mergeh(b, a) ++#define VEC_MERGEL(a, b) vec_mergel(b, a) ++#endif ++ ++#if HAVE_BIGENDIAN ++#define VEC_ST(a,b,c) vec_st(a,b,c) ++#else ++#define VEC_ST(a,b,c) vec_vsx_st(a,b,c) ++#endif ++ ++#if HAVE_BIGENDIAN ++#define VEC_SPLAT16(a,b) vec_splat((vec_s16)(a), b) ++#else ++#define VEC_SPLAT16(a,b) vec_splat((vec_s16)(vec_perm(a, a, vcswapi2s(0,1,2,3))), b) ++#endif ++ ++#if HAVE_BIGENDIAN ++#define VEC_SLD16(a,b,c) vec_sld(a, b, c) ++#else ++#define VEC_SLD16(a,b,c) vec_sld(b, a, c) ++#endif ++ ++#endif /* HAVE_ALTIVEC */ ++ ++#if HAVE_VSX ++#if HAVE_BIGENDIAN ++#define vsx_ld_u8_s16(off, p) \ ++ ((vec_s16)vec_mergeh((vec_u8)vec_splat_u8(0), \ ++ (vec_u8)vec_vsx_ld((off), (p)))) ++#else ++#define vsx_ld_u8_s16(off, p) \ ++ ((vec_s16)vec_mergeh((vec_u8)vec_vsx_ld((off), (p)), \ ++ (vec_u8)vec_splat_u8(0))) ++#endif /* HAVE_BIGENDIAN */ ++#endif /* HAVE_VSX */ ++ ++#endif /* AVUTIL_PPC_UTIL_ALTIVEC_H */ diff --git a/qtwebengine-chromium-5.13.2-ppc64.patch b/qtwebengine-chromium-5.13.2-ppc64.patch new file mode 100644 index 0000000..a0f8787 --- /dev/null +++ b/qtwebengine-chromium-5.13.2-ppc64.patch @@ -0,0 +1,17738 @@ +From bf6da5866b21deb7570f2a9251b766d3d9f3750a Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 13:24:55 +0100 +Subject: [PATCH 01/13] update sandbox for ppc64 + +--- + chromium/sandbox/features.gni | 2 +- + chromium/sandbox/linux/BUILD.gn | 2 + + .../linux/bpf_dsl/linux_syscall_ranges.h | 7 + + .../sandbox/linux/bpf_dsl/seccomp_macros.h | 48 +++++++ + .../seccomp-bpf-helpers/baseline_policy.cc | 10 +- + .../baseline_policy_unittest.cc | 2 + + .../syscall_parameters_restrictions.cc | 38 ++++- + .../syscall_parameters_restrictions.h | 2 +- + .../linux/seccomp-bpf-helpers/syscall_sets.cc | 132 +++++++++++------- + .../linux/seccomp-bpf-helpers/syscall_sets.h | 11 +- + chromium/sandbox/linux/seccomp-bpf/syscall.cc | 62 +++++++- + chromium/sandbox/linux/seccomp-bpf/trap.cc | 14 ++ + .../sandbox/linux/services/credentials.cc | 2 +- + .../linux/services/syscall_wrappers.cc | 2 +- + .../linux/syscall_broker/broker_process.cc | 2 +- + .../linux/system_headers/linux_seccomp.h | 9 ++ + .../linux/system_headers/linux_signal.h | 2 +- + .../linux/system_headers/linux_syscalls.h | 4 + + .../linux/system_headers/linux_ucontext.h | 2 + + .../system_headers/ppc64_linux_syscalls.h | 12 ++ + .../system_headers/ppc64_linux_ucontext.h | 12 ++ + .../linux/bpf_renderer_policy_linux.cc | 5 + + 22 files changed, 309 insertions(+), 73 deletions(-) + create mode 100644 chromium/sandbox/linux/system_headers/ppc64_linux_syscalls.h + create mode 100644 chromium/sandbox/linux/system_headers/ppc64_linux_ucontext.h + +diff --git a/chromium/sandbox/features.gni b/chromium/sandbox/features.gni +index 89693c54c4f..6017c7eea95 100644 +--- a/chromium/sandbox/features.gni ++++ b/chromium/sandbox/features.gni +@@ -12,6 +12,6 @@ use_seccomp_bpf = + (is_linux || is_android) && + (current_cpu == "x86" || current_cpu == "x64" || current_cpu == "arm" || + current_cpu == "arm64" || current_cpu == "mipsel" || +- current_cpu == "mips64el") ++ current_cpu == "mips64el" || current_cpu == "ppc64") + + use_seccomp_bpf = use_seccomp_bpf || is_nacl_nonsfi +diff --git a/chromium/sandbox/linux/BUILD.gn b/chromium/sandbox/linux/BUILD.gn +index b00a88cfa35..b3e55d5cb4d 100644 +--- a/chromium/sandbox/linux/BUILD.gn ++++ b/chromium/sandbox/linux/BUILD.gn +@@ -416,6 +416,8 @@ component("sandbox_services") { + + source_set("sandbox_services_headers") { + sources = [ ++ "system_headers/ppc64_linux_syscalls.h", ++ "system_headers/ppc64_linux_ucontext.h", + "system_headers/arm64_linux_syscalls.h", + "system_headers/arm_linux_syscalls.h", + "system_headers/arm_linux_ucontext.h", +diff --git a/chromium/sandbox/linux/bpf_dsl/linux_syscall_ranges.h b/chromium/sandbox/linux/bpf_dsl/linux_syscall_ranges.h +index 73c26c4ba66..e312589dcd1 100644 +--- a/chromium/sandbox/linux/bpf_dsl/linux_syscall_ranges.h ++++ b/chromium/sandbox/linux/bpf_dsl/linux_syscall_ranges.h +@@ -55,6 +55,13 @@ + #define MAX_PUBLIC_SYSCALL 279u + #define MAX_SYSCALL MAX_PUBLIC_SYSCALL + ++#elif defined(__powerpc64__) ++ ++#include ++#define MIN_SYSCALL 0u ++#define MAX_PUBLIC_SYSCALL 386u ++#define MAX_SYSCALL MAX_PUBLIC_SYSCALL ++ + #else + #error "Unsupported architecture" + #endif +diff --git a/chromium/sandbox/linux/bpf_dsl/seccomp_macros.h b/chromium/sandbox/linux/bpf_dsl/seccomp_macros.h +index 1a407b95237..a6aec544e09 100644 +--- a/chromium/sandbox/linux/bpf_dsl/seccomp_macros.h ++++ b/chromium/sandbox/linux/bpf_dsl/seccomp_macros.h +@@ -16,6 +16,9 @@ + #if defined(__mips__) + // sys/user.h in eglibc misses size_t definition + #include ++#elif defined(__powerpc64__) ++// Manually define greg_t on ppc64 ++typedef unsigned long long greg_t; + #endif + #endif + +@@ -346,6 +349,51 @@ struct regs_struct { + #define SECCOMP_PT_PARM4(_regs) (_regs).regs[3] + #define SECCOMP_PT_PARM5(_regs) (_regs).regs[4] + #define SECCOMP_PT_PARM6(_regs) (_regs).regs[5] ++ ++#elif defined(__powerpc64__) ++#include ++ ++typedef struct pt_regs regs_struct; ++ ++#ifdef ARCH_CPU_LITTLE_ENDIAN ++#define SECCOMP_ARCH AUDIT_ARCH_PPC64LE ++#else ++#define SECCOMP_ARCH AUDIT_ARCH_PPC64 ++#endif ++ ++#define SECCOMP_REG(_ctx, _reg) ((_ctx)->uc_mcontext.regs->gpr[_reg]) ++ ++#define SECCOMP_RESULT(_ctx) SECCOMP_REG(_ctx, 3) ++#define SECCOMP_SYSCALL(_ctx) SECCOMP_REG(_ctx, 0) ++#define SECCOMP_IP(_ctx) (_ctx)->uc_mcontext.regs->nip ++#define SECCOMP_PARM1(_ctx) SECCOMP_REG(_ctx, 3) ++#define SECCOMP_PARM2(_ctx) SECCOMP_REG(_ctx, 4) ++#define SECCOMP_PARM3(_ctx) SECCOMP_REG(_ctx, 5) ++#define SECCOMP_PARM4(_ctx) SECCOMP_REG(_ctx, 6) ++#define SECCOMP_PARM5(_ctx) SECCOMP_REG(_ctx, 7) ++#define SECCOMP_PARM6(_ctx) SECCOMP_REG(_ctx, 8) ++ ++#define SECCOMP_NR_IDX (offsetof(struct arch_seccomp_data, nr)) ++#define SECCOMP_ARCH_IDX (offsetof(struct arch_seccomp_data, arch)) ++#define SECCOMP_IP_MSB_IDX \ ++ (offsetof(struct arch_seccomp_data, instruction_pointer) + 4) ++#define SECCOMP_IP_LSB_IDX \ ++ (offsetof(struct arch_seccomp_data, instruction_pointer) + 0) ++#define SECCOMP_ARG_MSB_IDX(nr) \ ++ (offsetof(struct arch_seccomp_data, args) + 8 * (nr) + 4) ++#define SECCOMP_ARG_LSB_IDX(nr) \ ++ (offsetof(struct arch_seccomp_data, args) + 8 * (nr) + 0) ++ ++#define SECCOMP_PT_RESULT(_regs) (_regs).gpr[3] ++#define SECCOMP_PT_SYSCALL(_regs) (_regs).gpr[0] ++#define SECCOMP_PT_IP(_regs) (_regs).nip ++#define SECCOMP_PT_PARM1(_regs) (_regs).gpr[3] ++#define SECCOMP_PT_PARM2(_regs) (_regs).gpr[4] ++#define SECCOMP_PT_PARM3(_regs) (_regs).gpr[5] ++#define SECCOMP_PT_PARM4(_regs) (_regs).gpr[6] ++#define SECCOMP_PT_PARM5(_regs) (_regs).gpr[7] ++#define SECCOMP_PT_PARM6(_regs) (_regs).gpr[8] ++ + #else + #error Unsupported target platform + +diff --git a/chromium/sandbox/linux/seccomp-bpf-helpers/baseline_policy.cc b/chromium/sandbox/linux/seccomp-bpf-helpers/baseline_policy.cc +index 479d1ed55a3..e1b91c36678 100644 +--- a/chromium/sandbox/linux/seccomp-bpf-helpers/baseline_policy.cc ++++ b/chromium/sandbox/linux/seccomp-bpf-helpers/baseline_policy.cc +@@ -87,7 +87,8 @@ bool IsBaselinePolicyWatched(int sysno) { + SyscallSets::IsPrctl(sysno) || + SyscallSets::IsProcessGroupOrSession(sysno) || + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + SyscallSets::IsSocketCall(sysno) || + #endif + #if defined(__arm__) +@@ -199,7 +200,7 @@ ResultExpr EvaluateSyscallImpl(int fs_denied_errno, + } + + #if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + if (sysno == __NR_mmap) + return RestrictMmapFlags(); + #endif +@@ -217,7 +218,7 @@ ResultExpr EvaluateSyscallImpl(int fs_denied_errno, + return RestrictPrctl(); + + #if defined(__x86_64__) || defined(__arm__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + if (sysno == __NR_socketpair) { + // Only allow AF_UNIX, PF_UNIX. Crash if anything else is seen. + static_assert(AF_UNIX == PF_UNIX, +@@ -257,7 +258,8 @@ ResultExpr EvaluateSyscallImpl(int fs_denied_errno, + } + + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + if (SyscallSets::IsSocketCall(sysno)) + return RestrictSocketcallCommand(); + #endif +diff --git a/chromium/sandbox/linux/seccomp-bpf-helpers/baseline_policy_unittest.cc b/chromium/sandbox/linux/seccomp-bpf-helpers/baseline_policy_unittest.cc +index 662e4e9dbe3..a5d6755f461 100644 +--- a/chromium/sandbox/linux/seccomp-bpf-helpers/baseline_policy_unittest.cc ++++ b/chromium/sandbox/linux/seccomp-bpf-helpers/baseline_policy_unittest.cc +@@ -289,8 +289,10 @@ TEST_BASELINE_SIGSYS(__NR_timer_create); + #if !defined(__aarch64__) + TEST_BASELINE_SIGSYS(__NR_eventfd); + TEST_BASELINE_SIGSYS(__NR_inotify_init); ++#if !defined(__powerpc64__) + TEST_BASELINE_SIGSYS(__NR_vserver); + #endif ++#endif + + #if defined(LIBC_GLIBC) && !defined(OS_CHROMEOS) + BPF_TEST_C(BaselinePolicy, FutexEINVAL, BaselinePolicy) { +diff --git a/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions.cc b/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions.cc +index b8d01d10210..7ebf90dd18a 100644 +--- a/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions.cc ++++ b/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions.cc +@@ -35,7 +35,8 @@ + #include + #include + #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && !defined(__arm__) && \ +- !defined(__aarch64__) && !defined(PTRACE_GET_THREAD_AREA) ++ !defined(__aarch64__) && !defined(PTRACE_GET_THREAD_AREA) && \ ++ !defined(__powerpc64__) + // Also include asm/ptrace-abi.h since ptrace.h in older libc (for instance + // the one in Ubuntu 16.04 LTS) is missing PTRACE_GET_THREAD_AREA. + // asm/ptrace-abi.h doesn't exist on arm32 and PTRACE_GET_THREAD_AREA isn't +@@ -44,6 +45,11 @@ + #endif + #endif // !OS_NACL_NONSFI + ++// On PPC64, TCGETS is defined in terms of struct termios, so we must include termios.h ++#ifdef __powerpc64__ ++#include ++#endif ++ + #if defined(OS_ANDROID) + + #if !defined(F_DUPFD_CLOEXEC) +@@ -106,6 +112,15 @@ inline bool IsArchitectureMips() { + #endif + } + ++inline bool IsArchitecturePPC64() { ++#if defined(__powerpc64__) ++ return true; ++#else ++ return false; ++#endif ++} ++ ++ + // Ubuntu's version of glibc has a race condition in sem_post that can cause + // it to call futex(2) with bogus op arguments. To workaround this, we need + // to allow those futex(2) calls to fail with EINVAL, instead of crashing the +@@ -245,9 +260,11 @@ ResultExpr RestrictFcntlCommands() { + // operator. + // Glibc overrides the kernel's O_LARGEFILE value. Account for this. + uint64_t kOLargeFileFlag = O_LARGEFILE; +- if (IsArchitectureX86_64() || IsArchitectureI386() || IsArchitectureMips()) ++ if (IsArchitectureX86_64() || IsArchitectureI386() || IsArchitectureMips() \ ++ || IsArchitecturePPC64()) + kOLargeFileFlag = 0100000; + ++ + const Arg cmd(1); + const Arg long_arg(2); + +@@ -261,14 +278,23 @@ ResultExpr RestrictFcntlCommands() { + F_SETLKW, + F_GETLK, + F_DUPFD, +- F_DUPFD_CLOEXEC), +- Allow()) ++ F_DUPFD_CLOEXEC ++#if defined(__powerpc64__) ++// On PPC64, F_SETLK, F_GETLK, F_SETLKW are defined as the 64-bit variants ++// but glibc will sometimes still use the 32-bit versions. Allow both. ++ , ++ 5, /* F_GETLK (32) */ ++ 6, /* F_SETLK (32) */ ++ 7 /* F_SETLKW (32) */ ++#endif ++ ), ++ Allow()) + .Case(F_SETFL, + If((long_arg & ~kAllowedMask) == 0, Allow()).Else(CrashSIGSYS())) + .Default(CrashSIGSYS()); + } + +-#if defined(__i386__) || defined(__mips__) ++#if defined(__i386__) || defined(__mips__) || defined(__powerpc64__) + ResultExpr RestrictSocketcallCommand() { + // Unfortunately, we are unable to restrict the first parameter to + // socketpair(2). Whilst initially sounding bad, it's noteworthy that very +@@ -404,7 +430,7 @@ ResultExpr RestrictPrlimit(pid_t target_pid) { + ResultExpr RestrictPtrace() { + const Arg request(0); + return Switch(request).CASES(( +-#if !defined(__aarch64__) ++#if !defined(__aarch64__) && !defined(__powerpc64__) + PTRACE_GETREGS, + PTRACE_GETFPREGS, + #if defined(TRACE_GET_THREAD_AREA) +diff --git a/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions.h b/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions.h +index cb563dfc550..2b17800d4ff 100644 +--- a/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions.h ++++ b/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_parameters_restrictions.h +@@ -48,7 +48,7 @@ SANDBOX_EXPORT bpf_dsl::ResultExpr RestrictMprotectFlags(); + // O_NONBLOCK | O_SYNC | O_LARGEFILE | O_CLOEXEC | O_NOATIME. + SANDBOX_EXPORT bpf_dsl::ResultExpr RestrictFcntlCommands(); + +-#if defined(__i386__) || defined(__mips__) ++#if defined(__i386__) || defined(__mips__) || defined(__powerpc64__) + // Restrict socketcall(2) to only allow socketpair(2), send(2), recv(2), + // sendto(2), recvfrom(2), shutdown(2), sendmsg(2) and recvmsg(2). + SANDBOX_EXPORT bpf_dsl::ResultExpr RestrictSocketcallCommand(); +diff --git a/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_sets.cc b/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_sets.cc +index 7dbcc875229..dedbee1f368 100644 +--- a/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_sets.cc ++++ b/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_sets.cc +@@ -29,7 +29,8 @@ bool SyscallSets::IsAllowedGettime(int sysno) { + switch (sysno) { + case __NR_gettimeofday: + #if defined(__i386__) || defined(__x86_64__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_time: + #endif + return true; +@@ -40,12 +41,14 @@ bool SyscallSets::IsAllowedGettime(int sysno) { + case __NR_clock_nanosleep: // Could be allowed. + case __NR_clock_settime: // Privileged. + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_ftime: // Obsolete. + #endif + case __NR_settimeofday: // Privileged. + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_stime: + #endif + default: +@@ -111,7 +114,7 @@ bool SyscallSets::IsFileSystem(int sysno) { + case __NR_faccessat: // EPERM not a valid errno. + case __NR_fchmodat: + case __NR_fchownat: // Should be called chownat ? +-#if defined(__x86_64__) || defined(__aarch64__) ++#if defined(__x86_64__) || defined(__aarch64__) || defined(__powerpc64__) + case __NR_newfstatat: // fstatat(). EPERM not a valid errno. + #elif defined(__i386__) || defined(__arm__) || \ + (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) +@@ -130,7 +133,7 @@ bool SyscallSets::IsFileSystem(int sysno) { + case __NR_memfd_create: + case __NR_mkdirat: + case __NR_mknodat: +-#if defined(__i386__) ++#if defined(__i386__) || defined(__powerpc64__) + case __NR_oldlstat: + case __NR_oldstat: + #endif +@@ -144,7 +147,8 @@ bool SyscallSets::IsFileSystem(int sysno) { + #endif + case __NR_statfs: // EPERM not a valid errno. + #if defined(__i386__) || defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_statfs64: + #endif + case __NR_symlinkat: +@@ -154,7 +158,8 @@ bool SyscallSets::IsFileSystem(int sysno) { + case __NR_truncate64: + #endif + case __NR_unlinkat: +-#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ ++ defined(__powerpc64__) + case __NR_utime: + #endif + case __NR_utimensat: // New. +@@ -173,7 +178,8 @@ bool SyscallSets::IsAllowedFileSystemAccessViaFd(int sysno) { + #endif + return true; + // TODO(jln): these should be denied gracefully as well (moved below). +-#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ ++ defined(__powerpc64__) + case __NR_fadvise64: // EPERM not a valid errno. + #endif + #if defined(__i386__) +@@ -186,11 +192,12 @@ bool SyscallSets::IsAllowedFileSystemAccessViaFd(int sysno) { + case __NR_flock: // EPERM not a valid errno. + case __NR_fstatfs: // Give information about the whole filesystem. + #if defined(__i386__) || defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_fstatfs64: + #endif + case __NR_fsync: // EPERM not a valid errno. +-#if defined(__i386__) ++#if defined(__i386__) || defined(__powerpc64__) + case __NR_oldfstat: + #endif + #if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ +@@ -198,6 +205,8 @@ bool SyscallSets::IsAllowedFileSystemAccessViaFd(int sysno) { + case __NR_sync_file_range: // EPERM not a valid errno. + #elif defined(__arm__) + case __NR_arm_sync_file_range: // EPERM not a valid errno. ++#elif defined(__powerpc64__) ++ case __NR_sync_file_range2: // EPERM not a valid errno. + #endif + default: + return false; +@@ -223,7 +232,8 @@ bool SyscallSets::IsDeniedFileSystemAccessViaFd(int sysno) { + #endif + case __NR_getdents64: // EPERM not a valid errno. + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_readdir: + #endif + return true; +@@ -264,7 +274,7 @@ bool SyscallSets::IsGetSimpleId(int sysno) { + bool SyscallSets::IsProcessPrivilegeChange(int sysno) { + switch (sysno) { + case __NR_capset: +-#if defined(__i386__) || defined(__x86_64__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__powerpc64__) + case __NR_ioperm: // Intel privilege. + case __NR_iopl: // Intel privilege. + #endif +@@ -314,7 +324,8 @@ bool SyscallSets::IsAllowedSignalHandling(int sysno) { + case __NR_rt_sigprocmask: + case __NR_rt_sigreturn: + #if defined(__i386__) || defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_sigaction: + case __NR_sigprocmask: + case __NR_sigreturn: +@@ -331,7 +342,8 @@ bool SyscallSets::IsAllowedSignalHandling(int sysno) { + #endif + case __NR_signalfd4: + #if defined(__i386__) || defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_sigpending: + case __NR_sigsuspend: + #endif +@@ -355,7 +367,7 @@ bool SyscallSets::IsAllowedOperationOnFd(int sysno) { + #endif + case __NR_dup3: + #if defined(__x86_64__) || defined(__arm__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + case __NR_shutdown: + #endif + return true; +@@ -388,7 +400,7 @@ bool SyscallSets::IsAllowedProcessStartOrDeath(int sysno) { + case __NR_exit_group: + case __NR_wait4: + case __NR_waitid: +-#if defined(__i386__) ++#if defined(__i386__) || defined(__powerpc64__) + case __NR_waitpid: + #endif + return true; +@@ -405,7 +417,7 @@ bool SyscallSets::IsAllowedProcessStartOrDeath(int sysno) { + #endif + case __NR_set_tid_address: + case __NR_unshare: +-#if !defined(__mips__) && !defined(__aarch64__) ++#if !defined(__mips__) && !defined(__aarch64__) || defined(__powerpc64__) + case __NR_vfork: + #endif + default: +@@ -454,7 +466,7 @@ bool SyscallSets::IsAllowedGetOrModifySocket(int sysno) { + return true; + default: + #if defined(__x86_64__) || defined(__arm__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + case __NR_socketpair: // We will want to inspect its argument. + #endif + return false; +@@ -464,7 +476,7 @@ bool SyscallSets::IsAllowedGetOrModifySocket(int sysno) { + bool SyscallSets::IsDeniedGetOrModifySocket(int sysno) { + switch (sysno) { + #if defined(__x86_64__) || defined(__arm__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + case __NR_accept: + case __NR_accept4: + case __NR_bind: +@@ -479,7 +491,8 @@ bool SyscallSets::IsDeniedGetOrModifySocket(int sysno) { + } + + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + // Big multiplexing system call for sockets. + bool SyscallSets::IsSocketCall(int sysno) { + switch (sysno) { +@@ -493,7 +506,8 @@ bool SyscallSets::IsSocketCall(int sysno) { + } + #endif + +-#if defined(__x86_64__) || defined(__arm__) || defined(__mips__) ++#if defined(__x86_64__) || defined(__arm__) || defined(__mips__) || \ ++ defined(__powerpc64__) + bool SyscallSets::IsNetworkSocketInformation(int sysno) { + switch (sysno) { + case __NR_getpeername: +@@ -518,7 +532,7 @@ bool SyscallSets::IsAllowedAddressSpaceAccess(int sysno) { + case __NR_mincore: + case __NR_mlockall: + #if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + case __NR_mmap: + #endif + #if defined(__i386__) || defined(__arm__) || \ +@@ -548,7 +562,8 @@ bool SyscallSets::IsAllowedGeneralIo(int sysno) { + switch (sysno) { + case __NR_lseek: + #if defined(__i386__) || defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR__llseek: + #endif + #if !defined(__aarch64__) +@@ -560,26 +575,28 @@ bool SyscallSets::IsAllowedGeneralIo(int sysno) { + case __NR_readv: + case __NR_pread64: + #if defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_recv: + #endif + #if defined(__x86_64__) || defined(__arm__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + case __NR_recvfrom: // Could specify source. + case __NR_recvmsg: // Could specify source. + #endif +-#if defined(__i386__) || defined(__x86_64__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__powerpc64__) + case __NR_select: + #endif +-#if defined(__i386__) || defined(__arm__) || defined(__mips__) ++#if defined(__i386__) || defined(__arm__) || defined(__mips__) || defined(__powerpc64__) + case __NR__newselect: + #endif + #if defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_send: + #endif + #if defined(__x86_64__) || defined(__arm__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + case __NR_sendmsg: // Could specify destination. + case __NR_sendto: // Could specify destination. + #endif +@@ -636,7 +653,8 @@ bool SyscallSets::IsAllowedBasicScheduler(int sysno) { + return true; + case __NR_getpriority: + #if defined(__i386__) || defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_nice: + #endif + case __NR_setpriority: +@@ -648,7 +666,8 @@ bool SyscallSets::IsAllowedBasicScheduler(int sysno) { + bool SyscallSets::IsAdminOperation(int sysno) { + switch (sysno) { + #if defined(__i386__) || defined(__arm__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_bdflush: + #endif + case __NR_kexec_load: +@@ -664,7 +683,8 @@ bool SyscallSets::IsAdminOperation(int sysno) { + + bool SyscallSets::IsKernelModule(int sysno) { + switch (sysno) { +-#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ ++ defined(__powerpc64__) + case __NR_create_module: + case __NR_get_kernel_syms: // Should ENOSYS. + case __NR_query_module: +@@ -697,7 +717,8 @@ bool SyscallSets::IsFsControl(int sysno) { + case __NR_swapoff: + case __NR_swapon: + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_umount: + #endif + case __NR_umount2: +@@ -713,7 +734,7 @@ bool SyscallSets::IsNuma(int sysno) { + case __NR_getcpu: + case __NR_mbind: + #if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + case __NR_migrate_pages: + #endif + case __NR_move_pages: +@@ -742,14 +763,15 @@ bool SyscallSets::IsGlobalProcessEnvironment(int sysno) { + switch (sysno) { + case __NR_acct: // Privileged. + #if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + case __NR_getrlimit: + #endif +-#if defined(__i386__) || defined(__arm__) ++#if defined(__i386__) || defined(__arm__) || defined(__powerpc64__) + case __NR_ugetrlimit: + #endif + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_ulimit: + #endif + case __NR_getrusage: +@@ -783,7 +805,7 @@ bool SyscallSets::IsGlobalSystemStatus(int sysno) { + #endif + case __NR_sysinfo: + case __NR_uname: +-#if defined(__i386__) ++#if defined(__i386__) || defined(__powerpc64__) + case __NR_olduname: + case __NR_oldolduname: + #endif +@@ -846,7 +868,8 @@ bool SyscallSets::IsSystemVSemaphores(int sysno) { + #endif + + #if defined(__x86_64__) || defined(__arm__) || defined(__aarch64__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_64_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + // These give a lot of ambient authority and bypass the setuid sandbox. + bool SyscallSets::IsSystemVSharedMemory(int sysno) { + switch (sysno) { +@@ -877,7 +900,8 @@ bool SyscallSets::IsSystemVMessageQueue(int sysno) { + #endif + + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + // Big system V multiplexing system call. + bool SyscallSets::IsSystemVIpc(int sysno) { + switch (sysno) { +@@ -897,7 +921,8 @@ bool SyscallSets::IsAnySystemV(int sysno) { + return IsSystemVMessageQueue(sysno) || IsSystemVSemaphores(sysno) || + IsSystemVSharedMemory(sysno); + #elif defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + return IsSystemVIpc(sysno); + #endif + } +@@ -950,7 +975,8 @@ bool SyscallSets::IsFaNotify(int sysno) { + bool SyscallSets::IsTimer(int sysno) { + switch (sysno) { + case __NR_getitimer: +-#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ ++ defined(__powerpc64__) + case __NR_alarm: + #endif + case __NR_setitimer: +@@ -1009,18 +1035,22 @@ bool SyscallSets::IsMisc(int sysno) { + case __NR_syncfs: + case __NR_vhangup: + // The system calls below are not implemented. +-#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ ++ defined(__powerpc64__) + case __NR_afs_syscall: + #endif + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_break: + #endif +-#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ ++ defined(__powerpc64__) + case __NR_getpmsg: + #endif + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_gtty: + case __NR_idle: + case __NR_lock: +@@ -1028,20 +1058,22 @@ bool SyscallSets::IsMisc(int sysno) { + case __NR_prof: + case __NR_profil: + #endif +-#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || \ ++ defined(__powerpc64__) + case __NR_putpmsg: + #endif + #if defined(__x86_64__) + case __NR_security: + #endif + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + case __NR_stty: + #endif +-#if defined(__x86_64__) ++#if defined(__x86_64__) || defined(__powerpc64__) + case __NR_tuxcall: + #endif +-#if !defined(__aarch64__) ++#if !defined(__aarch64__) && !defined(__powerpc64__) + case __NR_vserver: + #endif + return true; +diff --git a/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_sets.h b/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_sets.h +index acd92da3956..3412873d07f 100644 +--- a/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_sets.h ++++ b/chromium/sandbox/linux/seccomp-bpf-helpers/syscall_sets.h +@@ -43,13 +43,14 @@ class SANDBOX_EXPORT SyscallSets { + static bool IsDeniedGetOrModifySocket(int sysno); + + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + // Big multiplexing system call for sockets. + static bool IsSocketCall(int sysno); + #endif + + #if defined(__x86_64__) || defined(__arm__) || defined(__mips__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + static bool IsNetworkSocketInformation(int sysno); + #endif + +@@ -76,7 +77,8 @@ class SANDBOX_EXPORT SyscallSets { + static bool IsSystemVSemaphores(int sysno); + #endif + #if defined(__x86_64__) || defined(__arm__) || defined(__aarch64__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_64_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_64_BITS)) || \ ++ defined(__powerpc64__) + // These give a lot of ambient authority and bypass the setuid sandbox. + static bool IsSystemVSharedMemory(int sysno); + #endif +@@ -87,7 +89,8 @@ class SANDBOX_EXPORT SyscallSets { + #endif + + #if defined(__i386__) || \ +- (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) ++ (defined(ARCH_CPU_MIPS_FAMILY) && defined(ARCH_CPU_32_BITS)) || \ ++ defined(__powerpc64__) + // Big system V multiplexing system call. + static bool IsSystemVIpc(int sysno); + #endif +diff --git a/chromium/sandbox/linux/seccomp-bpf/syscall.cc b/chromium/sandbox/linux/seccomp-bpf/syscall.cc +index 34edabd2b82..10fa5fd0705 100644 +--- a/chromium/sandbox/linux/seccomp-bpf/syscall.cc ++++ b/chromium/sandbox/linux/seccomp-bpf/syscall.cc +@@ -16,7 +16,7 @@ namespace sandbox { + namespace { + + #if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM_FAMILY) || \ +- defined(ARCH_CPU_MIPS_FAMILY) ++ defined(ARCH_CPU_MIPS_FAMILY) || defined (ARCH_CPU_PPC64_FAMILY) + // Number that's not currently used by any Linux kernel ABIs. + const int kInvalidSyscallNumber = 0x351d3; + #else +@@ -308,12 +308,56 @@ asm(// We need to be able to tell the kernel exactly where we made a + // Enter the kernel + "svc 0\n" + "2:ret\n" ++ ".cfi_endproc\n" ++ ".size SyscallAsm, .-SyscallAsm\n" ++#elif defined(__powerpc64__) ++ ".text\n" ++ ".align 4\n" ++ ".type SyscallAsm @function\n" ++ "SyscallAsm:\n" ++ ".cfi_startproc\n" ++ ++ // Check if r3 is negative ++ "cmpdi 3, 0\n" ++ "bgt 2f\n" ++ ++ // Load address of 3f into r3 and return ++ "mflr 10\n" ++ "bl 1f\n" ++ "1: mflr 3\n" ++ "mtlr 10\n" ++ "addi 3, 3, 4*13\n" ++ "blr\n" ++ ++ // Load arguments from array into r3-8 ++ // save param 3 in r10 ++ "2:\n" ++ "mr 0, 3\n" ++ "ld 3, 0(4)\n" ++ "ld 5, 16(4)\n" ++ "ld 6, 24(4)\n" ++ "ld 7, 32(4)\n" ++ "ld 8, 40(4)\n" ++ "ld 4, 8(4)\n" ++ "li 9, 0\n" ++ ++ // Enter kernel ++ "sc\n" ++ ++ // Magic return address ++ "3:\n" ++ // Like MIPS, ppc64 return values are always positive. ++ // Check for error in cr0.SO and negate upon error ++ "bc 4, 3, 4f\n" ++ "neg 3, 3\n" ++ "4: blr\n" ++ + ".cfi_endproc\n" + ".size SyscallAsm, .-SyscallAsm\n" + #endif + ); // asm + +-#if defined(__x86_64__) ++#if defined(__x86_64__) || defined(__powerpc64__) + extern "C" { + intptr_t SyscallAsm(intptr_t nr, const intptr_t args[6]); + } +@@ -427,6 +471,8 @@ intptr_t Syscall::Call(int nr, + ret = inout; + } + ++#elif defined(__powerpc64__) ++ intptr_t ret = SyscallAsm(nr, args); + #else + #error "Unimplemented architecture" + #endif +@@ -443,8 +489,18 @@ void Syscall::PutValueInUcontext(intptr_t ret_val, ucontext_t* ctx) { + // needs to be changed back. + ret_val = -ret_val; + SECCOMP_PARM4(ctx) = 1; +- } else ++ } else { + SECCOMP_PARM4(ctx) = 0; ++ } ++#endif ++#if defined(__powerpc64__) ++ // Same as MIPS, need to invert ret and set error register (cr0.SO) ++ if (ret_val <= -1 && ret_val >= -4095) { ++ ret_val = -ret_val; ++ ctx->uc_mcontext.regs->ccr |= (1 << 28); ++ } else { ++ ctx->uc_mcontext.regs->ccr &= ~(1 << 28); ++ } + #endif + SECCOMP_RESULT(ctx) = static_cast(ret_val); + } +diff --git a/chromium/sandbox/linux/seccomp-bpf/trap.cc b/chromium/sandbox/linux/seccomp-bpf/trap.cc +index 003708d2c89..8f9b3af4e2e 100644 +--- a/chromium/sandbox/linux/seccomp-bpf/trap.cc ++++ b/chromium/sandbox/linux/seccomp-bpf/trap.cc +@@ -225,6 +225,20 @@ void Trap::SigSys(int nr, LinuxSigInfo* info, ucontext_t* ctx) { + SetIsInSigHandler(); + } + ++#if defined(__powerpc64__) ++ // On ppc64+glibc, some syscalls seem to accidentally negate the first ++ // parameter which causes checks against it to fail. For now, manually ++ // negate them back. ++ // TODO(shawn@anastas.io): investigate this issue further ++ auto nr = SECCOMP_SYSCALL(ctx); ++ if (nr == __NR_openat || nr == __NR_mkdirat || nr == __NR_faccessat || nr == __NR_readlinkat || ++ nr == __NR_renameat || nr == __NR_renameat2 || nr == __NR_newfstatat || nr == __NR_unlinkat) { ++ if (static_cast(SECCOMP_PARM1(ctx)) > 0) { ++ SECCOMP_PARM1(ctx) = -SECCOMP_PARM1(ctx); ++ } ++ } ++#endif ++ + // Copy the seccomp-specific data into a arch_seccomp_data structure. This + // is what we are showing to TrapFnc callbacks that the system call + // evaluator registered with the sandbox. +diff --git a/chromium/sandbox/linux/services/credentials.cc b/chromium/sandbox/linux/services/credentials.cc +index 542567f3ee5..31d493c2641 100644 +--- a/chromium/sandbox/linux/services/credentials.cc ++++ b/chromium/sandbox/linux/services/credentials.cc +@@ -79,7 +79,7 @@ bool ChrootToSafeEmptyDir() { + pid_t pid = -1; + alignas(16) char stack_buf[PTHREAD_STACK_MIN]; + #if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM_FAMILY) || \ +- defined(ARCH_CPU_MIPS_FAMILY) ++ defined(ARCH_CPU_MIPS_FAMILY) || defined(ARCH_CPU_PPC64_FAMILY) + // The stack grows downward. + void* stack = stack_buf + sizeof(stack_buf); + #else +diff --git a/chromium/sandbox/linux/services/syscall_wrappers.cc b/chromium/sandbox/linux/services/syscall_wrappers.cc +index fcfd2aa129d..f6eb32fb762 100644 +--- a/chromium/sandbox/linux/services/syscall_wrappers.cc ++++ b/chromium/sandbox/linux/services/syscall_wrappers.cc +@@ -58,7 +58,7 @@ long sys_clone(unsigned long flags, + #if defined(ARCH_CPU_X86_64) + return syscall(__NR_clone, flags, child_stack, ptid, ctid, tls); + #elif defined(ARCH_CPU_X86) || defined(ARCH_CPU_ARM_FAMILY) || \ +- defined(ARCH_CPU_MIPS_FAMILY) ++ defined(ARCH_CPU_MIPS_FAMILY) || defined(ARCH_CPU_PPC64_FAMILY) + // CONFIG_CLONE_BACKWARDS defined. + return syscall(__NR_clone, flags, child_stack, ptid, tls, ctid); + #endif +diff --git a/chromium/sandbox/linux/syscall_broker/broker_process.cc b/chromium/sandbox/linux/syscall_broker/broker_process.cc +index 56d4964cfdc..a2e94eada56 100644 +--- a/chromium/sandbox/linux/syscall_broker/broker_process.cc ++++ b/chromium/sandbox/linux/syscall_broker/broker_process.cc +@@ -151,7 +151,7 @@ bool BrokerProcess::IsSyscallAllowed(int sysno) const { + #if defined(__NR_fstatat) + case __NR_fstatat: + #endif +-#if defined(__x86_64__) || defined(__aarch64__) ++#if defined(__x86_64__) || defined(__aarch64__) || defined(__powerpc64__) + case __NR_newfstatat: + #endif + return !fast_check_in_client_ || allowed_command_set_.test(COMMAND_STAT); +diff --git a/chromium/sandbox/linux/system_headers/linux_seccomp.h b/chromium/sandbox/linux/system_headers/linux_seccomp.h +index a60fe2ad3dc..9dccdb51d02 100644 +--- a/chromium/sandbox/linux/system_headers/linux_seccomp.h ++++ b/chromium/sandbox/linux/system_headers/linux_seccomp.h +@@ -29,6 +29,9 @@ + #ifndef EM_AARCH64 + #define EM_AARCH64 183 + #endif ++#ifndef EM_PPC64 ++#define EM_PPC64 21 ++#endif + + #ifndef __AUDIT_ARCH_64BIT + #define __AUDIT_ARCH_64BIT 0x80000000 +@@ -54,6 +57,12 @@ + #ifndef AUDIT_ARCH_AARCH64 + #define AUDIT_ARCH_AARCH64 (EM_AARCH64 | __AUDIT_ARCH_64BIT | __AUDIT_ARCH_LE) + #endif ++#ifndef AUDIT_ARCH_PPC64 ++#define AUDIT_ARCH_PPC64 (EM_PPC64 | __AUDIT_ARCH_64BIT) ++#endif ++#ifndef AUDIT_ARCH_PPC64LE ++#define AUDIT_ARCH_PPC64LE (EM_PPC64 | __AUDIT_ARCH_64BIT | __AUDIT_ARCH_LE) ++#endif + + // For prctl.h + #ifndef PR_SET_SECCOMP +diff --git a/chromium/sandbox/linux/system_headers/linux_signal.h b/chromium/sandbox/linux/system_headers/linux_signal.h +index f5a73676174..515b21a5fdf 100644 +--- a/chromium/sandbox/linux/system_headers/linux_signal.h ++++ b/chromium/sandbox/linux/system_headers/linux_signal.h +@@ -13,7 +13,7 @@ + // (not undefined, but defined different values and in different memory + // layouts). So, fill the gap here. + #if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || \ +- defined(__aarch64__) ++ defined(__aarch64__) || defined(__powerpc64__) + + #define LINUX_SIGHUP 1 + #define LINUX_SIGINT 2 +diff --git a/chromium/sandbox/linux/system_headers/linux_syscalls.h b/chromium/sandbox/linux/system_headers/linux_syscalls.h +index 2b78a0cc3b9..0a70f5ea588 100644 +--- a/chromium/sandbox/linux/system_headers/linux_syscalls.h ++++ b/chromium/sandbox/linux/system_headers/linux_syscalls.h +@@ -35,5 +35,9 @@ + #include "sandbox/linux/system_headers/arm64_linux_syscalls.h" + #endif + ++#if defined(__powerpc64__) ++#include "sandbox/linux/system_headers/ppc64_linux_syscalls.h" ++#endif ++ + #endif // SANDBOX_LINUX_SYSTEM_HEADERS_LINUX_SYSCALLS_H_ + +diff --git a/chromium/sandbox/linux/system_headers/linux_ucontext.h b/chromium/sandbox/linux/system_headers/linux_ucontext.h +index 22ce7802743..a69b024c2f3 100644 +--- a/chromium/sandbox/linux/system_headers/linux_ucontext.h ++++ b/chromium/sandbox/linux/system_headers/linux_ucontext.h +@@ -11,6 +11,8 @@ + #include "sandbox/linux/system_headers/arm_linux_ucontext.h" + #elif defined(__i386__) + #include "sandbox/linux/system_headers/i386_linux_ucontext.h" ++#elif defined(__powerpc64__) ++#include "sandbox/linux/system_headers/ppc64_linux_ucontext.h" + #else + #error "No support for your architecture in PNaCl header" + #endif +diff --git a/chromium/sandbox/linux/system_headers/ppc64_linux_syscalls.h b/chromium/sandbox/linux/system_headers/ppc64_linux_syscalls.h +new file mode 100644 +index 00000000000..ccacffe22ea +--- /dev/null ++++ b/chromium/sandbox/linux/system_headers/ppc64_linux_syscalls.h +@@ -0,0 +1,12 @@ ++// Copyright 2014 The Chromium Authors. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#ifndef SANDBOX_LINUX_SYSTEM_HEADERS_PPC64_LINUX_SYSCALLS_H_ ++#define SANDBOX_LINUX_SYSTEM_HEADERS_PPC64_LINUX_SYSCALLS_H_ ++ ++#include ++ ++//TODO: is it necessary to redefine syscall numbers for PPC64? ++ ++#endif // SANDBOX_LINUX_SYSTEM_HEADERS_PPC64_LINUX_SYSCALLS_H_ +diff --git a/chromium/sandbox/linux/system_headers/ppc64_linux_ucontext.h b/chromium/sandbox/linux/system_headers/ppc64_linux_ucontext.h +new file mode 100644 +index 00000000000..07728e08791 +--- /dev/null ++++ b/chromium/sandbox/linux/system_headers/ppc64_linux_ucontext.h +@@ -0,0 +1,12 @@ ++// Copyright 2014 The Chromium Authors. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#ifndef SANDBOX_LINUX_SYSTEM_HEADERS_PPC64_LINUX_UCONTEXT_H_ ++#define SANDBOX_LINUX_SYSTEM_HEADERS_PPC64_LINUX_UCONTEXT_H_ ++ ++#include ++ ++//TODO: is it necessary to redefine ucontext on PPC64? ++ ++#endif // SANDBOX_LINUX_SYSTEM_HEADERS_PPC64_LINUX_UCONTEXT_H_ +diff --git a/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc b/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc +index 017f13cf7ba..a76e579b7b3 100644 +--- a/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc ++++ b/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc +@@ -15,6 +15,11 @@ + #include "sandbox/linux/system_headers/linux_syscalls.h" + #include "services/service_manager/sandbox/linux/sandbox_linux.h" + ++// On PPC64, TCGETS is defined in terms of struct termios, so we must include termios.h ++#ifdef __powerpc64__ ++#include ++#endif ++ + // TODO(vignatti): replace the local definitions below with #include + // once kernel version 4.6 becomes widely used. + #include +-- +2.21.1 + + +From e3b739ad1855adb5234f1c948eafd572d4442240 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 13:33:12 +0100 +Subject: [PATCH 02/13] update third_party for ppc64 + +--- + .../angle/src/libANGLE/Constants.h | 1 + + .../blink/renderer/platform/heap/heap_page.h | 3 +- + chromium/third_party/boringssl/BUILD.gn | 7 + + chromium/third_party/libpng/BUILD.gn | 5 + + .../libpng/powerpc/filter_vsx_intrinsics.c | 767 ++++++++++++++++++ + .../third_party/libpng/powerpc/powerpc_init.c | 125 +++ + chromium/third_party/libvpx/BUILD.gn | 2 + + chromium/third_party/libvpx/generate_gni.sh | 10 + + .../third_party/lss/linux_syscall_support.h | 4 +- + chromium/third_party/node/node.py | 11 +- + 10 files changed, 927 insertions(+), 8 deletions(-) + create mode 100644 chromium/third_party/libpng/powerpc/filter_vsx_intrinsics.c + create mode 100644 chromium/third_party/libpng/powerpc/powerpc_init.c + +diff --git a/chromium/third_party/angle/src/libANGLE/Constants.h b/chromium/third_party/angle/src/libANGLE/Constants.h +index 392df475482..c09da815b5e 100644 +--- a/chromium/third_party/angle/src/libANGLE/Constants.h ++++ b/chromium/third_party/angle/src/libANGLE/Constants.h +@@ -9,6 +9,7 @@ + #ifndef LIBANGLE_CONSTANTS_H_ + #define LIBANGLE_CONSTANTS_H_ + ++#include + #include "common/platform.h" + + namespace gl +diff --git a/chromium/third_party/blink/renderer/platform/heap/heap_page.h b/chromium/third_party/blink/renderer/platform/heap/heap_page.h +index 063a6e0a78b..926a418a7f7 100644 +--- a/chromium/third_party/blink/renderer/platform/heap/heap_page.h ++++ b/chromium/third_party/blink/renderer/platform/heap/heap_page.h +@@ -67,11 +67,12 @@ constexpr size_t kBlinkPageBaseMask = ~kBlinkPageOffsetMask; + constexpr size_t kBlinkPagesPerRegion = 10; + + // TODO(nya): Replace this with something like #if ENABLE_NACL. +-#if 0 ++#if defined(ARCH_CPU_PPC64) + // NaCl's system page size is 64 KiB. This causes a problem in Oilpan's heap + // layout because Oilpan allocates two guard pages for each Blink page (whose + // size is kBlinkPageSize = 2^17 = 128 KiB). So we don't use guard pages in + // NaCl. ++// The same issue holds for ppc64 systems, which use a 64k page size. + constexpr size_t kBlinkGuardPageSize = 0; + #else + constexpr size_t kBlinkGuardPageSize = base::kSystemPageSize; +diff --git a/chromium/third_party/boringssl/BUILD.gn b/chromium/third_party/boringssl/BUILD.gn +index 8d460717d4c..9dee9747f57 100644 +--- a/chromium/third_party/boringssl/BUILD.gn ++++ b/chromium/third_party/boringssl/BUILD.gn +@@ -100,6 +100,13 @@ if (is_win && !is_msan && current_cpu != "arm64") { + } else { + public_configs = [ ":no_asm_config" ] + } ++ } else if (current_cpu == "ppc64") { ++ if (is_linux) { ++ # TODO: ppc64 (be) check ++ sources += crypto_sources_linux_ppc64le ++ } else { ++ public_configs = [ ":no_asm_config" ] ++ } + } else { + public_configs = [ ":no_asm_config" ] + } +diff --git a/chromium/third_party/libpng/BUILD.gn b/chromium/third_party/libpng/BUILD.gn +index cbdb867f2a0..37d7d580522 100644 +--- a/chromium/third_party/libpng/BUILD.gn ++++ b/chromium/third_party/libpng/BUILD.gn +@@ -93,6 +93,11 @@ source_set("libpng_sources") { + "mips/filter_msa_intrinsics.c", + "mips/mips_init.c", + ] ++ } else if (current_cpu == "ppc64") { ++ sources += [ ++ "powerpc/filter_vsx_intrinsics.c", ++ "powerpc/powerpc_init.c", ++ ] + } + + configs -= [ "//build/config/compiler:chromium_code" ] +diff --git a/chromium/third_party/libpng/powerpc/filter_vsx_intrinsics.c b/chromium/third_party/libpng/powerpc/filter_vsx_intrinsics.c +new file mode 100644 +index 00000000000..e3de496bdc9 +--- /dev/null ++++ b/chromium/third_party/libpng/powerpc/filter_vsx_intrinsics.c +@@ -0,0 +1,767 @@ ++/* filter_vsx_intrinsics.c - PowerPC optimised filter functions ++ * ++ * Copyright (c) 2017 Glenn Randers-Pehrson ++ * Written by Vadim Barkov, 2017. ++ * Last changed in libpng 1.6.29 [March 16, 2017] ++ * ++ * This code is released under the libpng license. ++ * For conditions of distribution and use, see the disclaimer ++ * and license in png.h ++ */ ++#include ++#include ++#include "../pngpriv.h" ++ ++#ifdef PNG_READ_SUPPORTED ++ ++/* This code requires -maltivec and -mvsx on the command line: */ ++#if PNG_POWERPC_VSX_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */ ++ ++#include ++ ++#if PNG_POWERPC_VSX_OPT > 0 ++ ++#ifndef __VSX__ ++# error "This code requires VSX support (POWER7 and later). Please provide -mvsx compiler flag." ++#endif ++ ++#define vec_ld_unaligned(vec,data) vec = vec_vsx_ld(0,data) ++#define vec_st_unaligned(vec,data) vec_vsx_st(vec,0,data) ++ ++ ++/* Functions in this file look at most 3 pixels (a,b,c) to predict the 4th (d). ++ * They're positioned like this: ++ * prev: c b ++ * row: a d ++ * The Sub filter predicts d=a, Avg d=(a+b)/2, and Paeth predicts d to be ++ * whichever of a, b, or c is closest to p=a+b-c. ++ * ( this is taken from ../intel/filter_sse2_intrinsics.c ) ++ */ ++ ++#define vsx_declare_common_vars(row_info,row,prev_row,offset) \ ++ png_byte i;\ ++ png_bytep rp = row + offset;\ ++ png_const_bytep pp = prev_row;\ ++ png_size_t unaligned_top = 16 - (((png_size_t)rp % 16));\ ++ png_size_t istop;\ ++ if(unaligned_top == 16)\ ++ unaligned_top = 0;\ ++ istop = row_info->rowbytes;\ ++ if((unaligned_top < istop))\ ++ istop -= unaligned_top;\ ++ else{\ ++ unaligned_top = istop;\ ++ istop = 0;\ ++ } ++ ++void png_read_filter_row_up_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vsx_declare_common_vars(row_info,row,prev_row,0) ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ rp_vec = vec_ld(0,rp); ++ vec_ld_unaligned(pp_vec,pp); ++ ++ rp_vec = vec_add(rp_vec,pp_vec); ++ ++ vec_st(rp_vec,0,rp); ++ ++ pp += 16; ++ rp += 16; ++ istop -= 16; ++ } ++ ++ if(istop > 0) ++ { ++ /* If byte count of row is not divisible by 16 ++ * we will process remaining part as usual ++ */ ++ for (i = 0; i < istop; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); ++ rp++; ++ } ++} ++ ++} ++ ++static const vector unsigned char VSX_LEFTSHIFTED1_4 = {16,16,16,16, 0, 1, 2, 3,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED2_4 = {16,16,16,16,16,16,16,16, 4, 5, 6, 7,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 8, 9,10,11}; ++ ++static const vector unsigned char VSX_LEFTSHIFTED1_3 = {16,16,16, 0, 1, 2,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED2_3 = {16,16,16,16,16,16, 3, 4, 5,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED3_3 = {16,16,16,16,16,16,16,16,16, 6, 7, 8,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 9,10,11,16}; ++ ++static const vector unsigned char VSX_NOT_SHIFTED1_4 = {16,16,16,16, 4, 5, 6, 7,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED2_4 = {16,16,16,16,16,16,16,16, 8, 9,10,11,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED3_4 = {16,16,16,16,16,16,16,16,16,16,16,16,12,13,14,15}; ++ ++static const vector unsigned char VSX_NOT_SHIFTED1_3 = {16,16,16, 3, 4, 5,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED2_3 = {16,16,16,16,16,16, 6, 7, 8,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED3_3 = {16,16,16,16,16,16,16,16,16, 9,10,11,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED4_3 = {16,16,16,16,16,16,16,16,16,16,16,16,12,13,14,16}; ++ ++static const vector unsigned char VSX_CHAR_ZERO = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; ++#ifdef __LITTLE_ENDIAN__ ++ ++static const vector unsigned char VSX_CHAR_TO_SHORT1_4 = { 4,16, 5,16, 6,16, 7,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT2_4 = { 8,16, 9,16,10,16,11,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT3_4 = {12,16,13,16,14,16,15,16,16,16,16,16,16,16,16,16}; ++ ++static const vector unsigned char VSX_SHORT_TO_CHAR1_4 = {16,16,16,16, 0, 2, 4, 6,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR2_4 = {16,16,16,16,16,16,16,16, 0, 2, 4, 6,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 0, 2, 4, 6}; ++ ++static const vector unsigned char VSX_CHAR_TO_SHORT1_3 = { 3,16, 4,16, 5,16,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT2_3 = { 6,16, 7,16, 8,16,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT3_3 = { 9,16,10,16,11,16,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT4_3 = {12,16,13,16,14,16,16,16,16,16,16,16,16,16,16,16}; ++ ++static const vector unsigned char VSX_SHORT_TO_CHAR1_3 = {16,16,16, 0, 2, 4,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR2_3 = {16,16,16,16,16,16, 0, 2, 4,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR3_3 = {16,16,16,16,16,16,16,16,16, 0, 2, 4,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 0, 2, 4,16}; ++ ++#elif defined(__BIG_ENDIAN__) ++ ++static const vector unsigned char VSX_CHAR_TO_SHORT1_4 = {16, 4,16, 5,16, 6,16, 7,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT2_4 = {16, 8,16, 9,16,10,16,11,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT3_4 = {16,12,16,13,16,14,16,15,16,16,16,16,16,16,16,16}; ++ ++static const vector unsigned char VSX_SHORT_TO_CHAR1_4 = {16,16,16,16, 1, 3, 5, 7,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR2_4 = {16,16,16,16,16,16,16,16, 1, 3, 5, 7,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 1, 3, 5, 7}; ++ ++static const vector unsigned char VSX_CHAR_TO_SHORT1_3 = {16, 3,16, 4,16, 5,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT2_3 = {16, 6,16, 7,16, 8,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT3_3 = {16, 9,16,10,16,11,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT4_3 = {16,12,16,13,16,14,16,16,16,16,16,16,16,16,16,16}; ++ ++static const vector unsigned char VSX_SHORT_TO_CHAR1_3 = {16,16,16, 1, 3, 5,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR2_3 = {16,16,16,16,16,16, 1, 3, 5,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR3_3 = {16,16,16,16,16,16,16,16,16, 1, 3, 5,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 1, 3, 5,16}; ++ ++#endif ++ ++#define vsx_char_to_short(vec,offset,bpp) (vector unsigned short)vec_perm((vec),VSX_CHAR_ZERO,VSX_CHAR_TO_SHORT##offset##_##bpp) ++#define vsx_short_to_char(vec,offset,bpp) vec_perm(((vector unsigned char)(vec)),VSX_CHAR_ZERO,VSX_SHORT_TO_CHAR##offset##_##bpp) ++ ++#ifdef PNG_USE_ABS ++# define vsx_abs(number) abs(number) ++#else ++# define vsx_abs(number) (number > 0) ? (number) : -(number) ++#endif ++ ++void png_read_filter_row_sub4_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 4; ++ ++ vector unsigned char rp_vec; ++ vector unsigned char part_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ ++ PNG_UNUSED(pp) ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ for(i=0;i < bpp ; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ rp -= bpp; ++ ++ rp_vec = vec_ld(0,rp); ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_4); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_4); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_4); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 16; ++ istop -= 16; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp - bpp))) & 0xff); ++ rp++; ++ } ++ ++} ++ ++void png_read_filter_row_sub3_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 3; ++ ++ vector unsigned char rp_vec; ++ vector unsigned char part_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ ++ PNG_UNUSED(pp) ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ for(i=0;i < bpp ; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ rp -= bpp; ++ ++ rp_vec = vec_ld(0,rp); ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_3); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_3); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_3); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED4_3); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ vec_st(rp_vec,0,rp); ++ rp += 15; ++ istop -= 16; ++ ++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must ++ * be proceeded manually ++ */ ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++} ++ ++void png_read_filter_row_avg4_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 4; ++ ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vector unsigned char pp_part_vec; ++ vector unsigned char rp_part_vec; ++ vector unsigned char avg_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ rp -= bpp; ++ if(istop >= bpp) ++ istop -= bpp; ++ ++ for (i = 0; i < bpp; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ ((int)(*pp++) / 2 )) & 0xff); ++ ++ rp++; ++ } ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ for(i=0;i < bpp ; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++ rp -= bpp; ++ pp -= bpp; ++ ++ vec_ld_unaligned(pp_vec,pp); ++ rp_vec = vec_ld(0,rp); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_4); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED1_4); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_4); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED2_4); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_4); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED3_4); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 16; ++ pp += 16; ++ istop -= 16; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++} ++ ++void png_read_filter_row_avg3_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 3; ++ ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vector unsigned char pp_part_vec; ++ vector unsigned char rp_part_vec; ++ vector unsigned char avg_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ rp -= bpp; ++ if(istop >= bpp) ++ istop -= bpp; ++ ++ for (i = 0; i < bpp; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ ((int)(*pp++) / 2 )) & 0xff); ++ ++ rp++; ++ } ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ for(i=0;i < bpp ; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++ rp -= bpp; ++ pp -= bpp; ++ ++ vec_ld_unaligned(pp_vec,pp); ++ rp_vec = vec_ld(0,rp); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_3); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED1_3); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_3); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED2_3); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_3); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED3_3); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED4_3); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED4_3); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 15; ++ pp += 15; ++ istop -= 16; ++ ++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must ++ * be proceeded manually ++ */ ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ rp++; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++} ++ ++/* Bytewise c ? t : e. */ ++#define if_then_else(c,t,e) vec_sel(e,t,c) ++ ++#define vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) {\ ++ c = *(pp - bpp);\ ++ a = *(rp - bpp);\ ++ b = *pp++;\ ++ p = b - c;\ ++ pc = a - c;\ ++ pa = vsx_abs(p);\ ++ pb = vsx_abs(pc);\ ++ pc = vsx_abs(p + pc);\ ++ if (pb < pa) pa = pb, a = b;\ ++ if (pc < pa) a = c;\ ++ a += *rp;\ ++ *rp++ = (png_byte)a;\ ++ } ++ ++void png_read_filter_row_paeth4_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 4; ++ ++ int a, b, c, pa, pb, pc, p; ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vector unsigned short a_vec,b_vec,c_vec,nearest_vec; ++ vector signed short pa_vec,pb_vec,pc_vec,smallest_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ rp -= bpp; ++ if(istop >= bpp) ++ istop -= bpp; ++ ++ /* Process the first pixel in the row completely (this is the same as 'up' ++ * because there is only one candidate predictor for the first row). ++ */ ++ for(i = 0; i < bpp ; i++) ++ { ++ *rp = (png_byte)( *rp + *pp); ++ rp++; ++ pp++; ++ } ++ ++ for(i = 0; i < unaligned_top ; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ while( istop >= 16) ++ { ++ for(i = 0; i < bpp ; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ rp -= bpp; ++ pp -= bpp; ++ rp_vec = vec_ld(0,rp); ++ vec_ld_unaligned(pp_vec,pp); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_4),1,4); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED1_4),1,4); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_4),1,4); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,1,4))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_4),2,4); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED2_4),2,4); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_4),2,4); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,2,4))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_4),3,4); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED3_4),3,4); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_4),3,4); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,3,4))); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 16; ++ pp += 16; ++ istop -= 16; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++} ++ ++void png_read_filter_row_paeth3_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 3; ++ ++ int a, b, c, pa, pb, pc, p; ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vector unsigned short a_vec,b_vec,c_vec,nearest_vec; ++ vector signed short pa_vec,pb_vec,pc_vec,smallest_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ rp -= bpp; ++ if(istop >= bpp) ++ istop -= bpp; ++ ++ /* Process the first pixel in the row completely (this is the same as 'up' ++ * because there is only one candidate predictor for the first row). ++ */ ++ for(i = 0; i < bpp ; i++) ++ { ++ *rp = (png_byte)( *rp + *pp); ++ rp++; ++ pp++; ++ } ++ ++ for(i = 0; i < unaligned_top ; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ while( istop >= 16) ++ { ++ for(i = 0; i < bpp ; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ rp -= bpp; ++ pp -= bpp; ++ rp_vec = vec_ld(0,rp); ++ vec_ld_unaligned(pp_vec,pp); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_3),1,3); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED1_3),1,3); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_3),1,3); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,1,3))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_3),2,3); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED2_3),2,3); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_3),2,3); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,2,3))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_3),3,3); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED3_3),3,3); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_3),3,3); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,3,3))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED4_3),4,3); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED4_3),4,3); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED4_3),4,3); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,4,3))); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 15; ++ pp += 15; ++ istop -= 16; ++ ++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must ++ * be proceeded manually ++ */ ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++} ++ ++#endif /* PNG_POWERPC_VSX_OPT > 0 */ ++#endif /* PNG_POWERPC_VSX_IMPLEMENTATION == 1 (intrinsics) */ ++#endif /* READ */ +diff --git a/chromium/third_party/libpng/powerpc/powerpc_init.c b/chromium/third_party/libpng/powerpc/powerpc_init.c +new file mode 100644 +index 00000000000..07016177c5f +--- /dev/null ++++ b/chromium/third_party/libpng/powerpc/powerpc_init.c +@@ -0,0 +1,125 @@ ++ ++/* powerpc_init.c - POWERPC optimised filter functions ++ * ++ * Copyright (c) 2017 Glenn Randers-Pehrson ++ * Written by Vadim Barkov, 2017. ++ * Last changed in libpng 1.6.29 [March 16, 2017] ++ * ++ * This code is released under the libpng license. ++ * For conditions of distribution and use, see the disclaimer ++ * and license in png.h ++ */ ++/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are ++ * called. ++ */ ++#define _POSIX_SOURCE 1 ++ ++#include ++#include "../pngpriv.h" ++ ++#ifdef PNG_READ_SUPPORTED ++ ++#if PNG_POWERPC_VSX_OPT > 0 ++#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED /* Do run-time checks */ ++/* WARNING: it is strongly recommended that you do not build libpng with ++ * run-time checks for CPU features if at all possible. In the case of the PowerPC ++ * VSX instructions there is no processor-specific way of detecting the ++ * presence of the required support, therefore run-time detection is extremely ++ * OS specific. ++ * ++ * You may set the macro PNG_POWERPC_VSX_FILE to the file name of file containing ++ * a fragment of C source code which defines the png_have_vsx function. There ++ * are a number of implementations in contrib/powerpc-vsx, but the only one that ++ * has partial support is contrib/powerpc-vsx/linux.c - a generic Linux ++ * implementation which reads /proc/cpufino. ++ */ ++#ifndef PNG_POWERPC_VSX_FILE ++# ifdef __linux__ ++# define PNG_POWERPC_VSX_FILE "contrib/powerpc-vsx/linux_aux.c" ++# endif ++#endif ++ ++#ifdef PNG_POWERPC_VSX_FILE ++ ++#include /* for sig_atomic_t */ ++static int png_have_vsx(png_structp png_ptr); ++#include PNG_POWERPC_VSX_FILE ++ ++#else /* PNG_POWERPC_VSX_FILE */ ++# error "PNG_POWERPC_VSX_FILE undefined: no support for run-time POWERPC VSX checks" ++#endif /* PNG_POWERPC_VSX_FILE */ ++#endif /* PNG_POWERPC_VSX_CHECK_SUPPORTED */ ++ ++void ++png_init_filter_functions_vsx(png_structp pp, unsigned int bpp) ++{ ++ /* The switch statement is compiled in for POWERPC_VSX_API, the call to ++ * png_have_vsx is compiled in for POWERPC_VSX_CHECK. If both are defined ++ * the check is only performed if the API has not set the PowerPC option on ++ * or off explicitly. In this case the check controls what happens. ++ */ ++ ++#ifdef PNG_POWERPC_VSX_API_SUPPORTED ++ switch ((pp->options >> PNG_POWERPC_VSX) & 3) ++ { ++ case PNG_OPTION_UNSET: ++ /* Allow the run-time check to execute if it has been enabled - ++ * thus both API and CHECK can be turned on. If it isn't supported ++ * this case will fall through to the 'default' below, which just ++ * returns. ++ */ ++#endif /* PNG_POWERPC_VSX_API_SUPPORTED */ ++#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED ++ { ++ static volatile sig_atomic_t no_vsx = -1; /* not checked */ ++ ++ if (no_vsx < 0) ++ no_vsx = !png_have_vsx(pp); ++ ++ if (no_vsx) ++ return; ++ } ++#ifdef PNG_POWERPC_VSX_API_SUPPORTED ++ break; ++#endif ++#endif /* PNG_POWERPC_VSX_CHECK_SUPPORTED */ ++ ++#ifdef PNG_POWERPC_VSX_API_SUPPORTED ++ default: /* OFF or INVALID */ ++ return; ++ ++ case PNG_OPTION_ON: ++ /* Option turned on */ ++ break; ++ } ++#endif ++ ++ /* IMPORTANT: any new internal functions used here must be declared using ++ * PNG_INTERNAL_FUNCTION in ../pngpriv.h. This is required so that the ++ * 'prefix' option to configure works: ++ * ++ * ./configure --with-libpng-prefix=foobar_ ++ * ++ * Verify you have got this right by running the above command, doing a build ++ * and examining pngprefix.h; it must contain a #define for every external ++ * function you add. (Notice that this happens automatically for the ++ * initialization function.) ++ */ ++ pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_vsx; ++ ++ if (bpp == 3) ++ { ++ pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_vsx; ++ pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_vsx; ++ pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth3_vsx; ++ } ++ ++ else if (bpp == 4) ++ { ++ pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_vsx; ++ pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_vsx; ++ pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth4_vsx; ++ } ++} ++#endif /* PNG_POWERPC_VSX_OPT > 0 */ ++#endif /* READ */ +diff --git a/chromium/third_party/libvpx/BUILD.gn b/chromium/third_party/libvpx/BUILD.gn +index 1cb05934d4c..225cc81bf41 100644 +--- a/chromium/third_party/libvpx/BUILD.gn ++++ b/chromium/third_party/libvpx/BUILD.gn +@@ -348,6 +348,8 @@ static_library("bundled_libvpx") { + } else { + sources = libvpx_srcs_arm64 + } ++ } else if (current_cpu == "ppc64") { ++ sources = libvpx_srcs_ppc64 + } + + configs -= [ "//build/config/compiler:chromium_code" ] +diff --git a/chromium/third_party/libvpx/generate_gni.sh b/chromium/third_party/libvpx/generate_gni.sh +index 8c0ac5c5418..29860d7cf75 100755 +--- a/chromium/third_party/libvpx/generate_gni.sh ++++ b/chromium/third_party/libvpx/generate_gni.sh +@@ -353,6 +353,7 @@ gen_config_files linux/arm-neon-highbd "--target=armv7-linux-gcc ${all_platforms + gen_config_files linux/arm64-highbd "--target=armv8-linux-gcc ${all_platforms} ${HIGHBD}" + gen_config_files linux/mipsel "--target=mips32-linux-gcc ${all_platforms}" + gen_config_files linux/mips64el "--target=mips64-linux-gcc ${all_platforms}" ++gen_config_files linux/ppc64 "--target=ppc64le-linux-gcc ${all_platforms}" + gen_config_files linux/generic "--target=generic-gnu $HIGHBD ${all_platforms}" + gen_config_files win/arm64 "--target=arm64-win64-vs15 ${all_platforms} ${HIGHBD}" + gen_config_files win/ia32 "--target=x86-win32-vs14 ${all_platforms} ${x86_platforms}" +@@ -378,6 +379,7 @@ lint_config linux/arm-neon-highbd + lint_config linux/arm64-highbd + lint_config linux/mipsel + lint_config linux/mips64el ++lint_config linux/ppc64 + lint_config linux/generic + lint_config win/arm64 + lint_config win/ia32 +@@ -407,6 +409,7 @@ gen_rtcd_header linux/arm-neon-highbd armv7 + gen_rtcd_header linux/arm64-highbd armv8 + gen_rtcd_header linux/mipsel mipsel + gen_rtcd_header linux/mips64el mips64el ++gen_rtcd_header linux/ppc64 ppc + gen_rtcd_header linux/generic generic + gen_rtcd_header win/arm64 armv8 + gen_rtcd_header win/ia32 x86 "${require_sse2}" +@@ -489,6 +492,13 @@ if [ -z $ONLY_CONFIGS ]; then + + echo "MIPS64 source list is identical to MIPS source list. No need to generate it." + ++ echo "Generate ppc64 source list." ++ config=$(print_config_basic linux/ppc64) ++ make_clean ++ make libvpx_srcs.txt target=libs $config > /dev/null ++ convert_srcs_to_project_files libvpx_srcs.txt libvpx_srcs_ppc64 ++ ++ + echo "Generate NaCl source list." + config=$(print_config_basic nacl) + make_clean +diff --git a/chromium/third_party/lss/linux_syscall_support.h b/chromium/third_party/lss/linux_syscall_support.h +index 5d9c2e8582f..ff2b35beca4 100644 +--- a/chromium/third_party/lss/linux_syscall_support.h ++++ b/chromium/third_party/lss/linux_syscall_support.h +@@ -3905,7 +3905,7 @@ struct kernel_statfs { + LSS_REG(2, buf); + LSS_BODY(void*, mmap2, "0"(__r2)); + } +-#else ++#elif !defined(__powerpc64__) /* ppc64 doesn't have mmap2 */ + #define __NR__mmap2 __NR_mmap2 + LSS_INLINE _syscall6(void*, _mmap2, void*, s, + size_t, l, int, p, +@@ -4036,7 +4036,7 @@ struct kernel_statfs { + #if defined(__i386__) || \ + defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \ + (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || \ +- defined(__PPC__) || \ ++ (defined(__PPC__) && !defined(__powerpc64__)) || \ + (defined(__s390__) && !defined(__s390x__)) + /* On these architectures, implement mmap() with mmap2(). */ + LSS_INLINE void* LSS_NAME(mmap)(void *s, size_t l, int p, int f, int d, +diff --git a/chromium/third_party/node/node.py b/chromium/third_party/node/node.py +index 8097e2c49ac..10e6a16eab1 100755 +--- a/chromium/third_party/node/node.py ++++ b/chromium/third_party/node/node.py +@@ -10,11 +10,12 @@ import sys + + + def GetBinaryPath(): +- return os_path.join(os_path.dirname(__file__), *{ +- 'Darwin': ('mac', 'node-darwin-x64', 'bin', 'node'), +- 'Linux': ('linux', 'node-linux-x64', 'bin', 'node'), +- 'Windows': ('win', 'node.exe'), +- }[platform.system()]) ++ return "/usr/bin/node" ++ #return os_path.join(os_path.dirname(__file__), *{ ++ # 'Darwin': ('mac', 'node-darwin-x64', 'bin', 'node'), ++ # 'Linux': ('linux', 'node-linux-x64', 'bin', 'node'), ++ # 'Windows': ('win', 'node.exe'), ++ #}[platform.system()]) + + + def RunNode(cmd_parts, stdout=None): +-- +2.21.1 + + +From 28cc659a8e651e90bfdc07eefea3fb6ab558c10e Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 13:34:01 +0100 +Subject: [PATCH 03/13] update webrtc for ppc64 + +--- + .../webrtc/modules/desktop_capture/differ_block.cc | 10 +++++----- + chromium/third_party/webrtc/rtc_base/system/arch.h | 12 ++++++++++++ + 2 files changed, 17 insertions(+), 5 deletions(-) + +diff --git a/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc b/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc +index dd9ab457e0f..c005d95990a 100644 +--- a/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc ++++ b/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc +@@ -30,11 +30,7 @@ bool VectorDifference(const uint8_t* image1, const uint8_t* image2) { + static bool (*diff_proc)(const uint8_t*, const uint8_t*) = nullptr; + + if (!diff_proc) { +-#if defined(WEBRTC_ARCH_ARM_FAMILY) || defined(WEBRTC_ARCH_MIPS_FAMILY) +- // For ARM and MIPS processors, always use C version. +- // TODO(hclam): Implement a NEON version. +- diff_proc = &VectorDifference_C; +-#else ++#if defined(WEBRTC_ARCH_X86_FAMILY) + bool have_sse2 = WebRtc_GetCPUInfo(kSSE2) != 0; + // For x86 processors, check if SSE2 is supported. + if (have_sse2 && kBlockSize == 32) { +@@ -44,6 +40,10 @@ bool VectorDifference(const uint8_t* image1, const uint8_t* image2) { + } else { + diff_proc = &VectorDifference_C; + } ++#else ++ // For other processors, always use C version. ++ // TODO(hclam): Implement a NEON version. ++ diff_proc = &VectorDifference_C; + #endif + } + +diff --git a/chromium/third_party/webrtc/rtc_base/system/arch.h b/chromium/third_party/webrtc/rtc_base/system/arch.h +index a2a11806445..e5fad1f6fd9 100644 +--- a/chromium/third_party/webrtc/rtc_base/system/arch.h ++++ b/chromium/third_party/webrtc/rtc_base/system/arch.h +@@ -47,6 +47,18 @@ + #elif defined(__pnacl__) + #define WEBRTC_ARCH_32_BITS + #define WEBRTC_ARCH_LITTLE_ENDIAN ++#elif defined(__PPC__) ++#define WEBRTC_ARCH_PPC_FAMILY ++#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ ++#define WEBRTC_ARCH_LITTLE_ENDIAN ++#else ++#define WEBRTC_ARCH_BIG_ENDIAN ++#endif ++#if defined(__LP64__) ++#define WEBRTC_ARCH_64_BITS ++#else ++#define WEBRTC_ARCH_32_BITS ++#endif + #else + #error Please add support for your architecture in typedefs.h + #endif +-- +2.21.1 + + +From 2ea66b427157fb406f97d8ee149a23e385d3fda5 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 13:38:51 +0100 +Subject: [PATCH 04/13] update third_party/sqlite for ppc64 + +--- + chromium/third_party/sqlite/amalgamation/sqlite3.c | 3 ++- + chromium/third_party/sqlite/src/src/sqliteInt.h | 3 ++- + 2 files changed, 4 insertions(+), 2 deletions(-) + +diff --git a/chromium/third_party/sqlite/amalgamation/sqlite3.c b/chromium/third_party/sqlite/amalgamation/sqlite3.c +index af9dbabe27e..d4e8577f25f 100644 +--- a/chromium/third_party/sqlite/amalgamation/sqlite3.c ++++ b/chromium/third_party/sqlite/amalgamation/sqlite3.c +@@ -13937,7 +13937,8 @@ typedef INT16_TYPE LogEst; + # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ +- defined(__arm__) || defined(_M_ARM64) ++ defined(__arm__) || defined(_M_ARM64) || \ ++ defined(__powerpc64__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) + # define SQLITE_BYTEORDER 1234 + # elif defined(sparc) || defined(__ppc__) + # define SQLITE_BYTEORDER 4321 +diff --git a/chromium/third_party/sqlite/src/src/sqliteInt.h b/chromium/third_party/sqlite/src/src/sqliteInt.h +index 467a273a995..7b3ea714c7b 100644 +--- a/chromium/third_party/sqlite/src/src/sqliteInt.h ++++ b/chromium/third_party/sqlite/src/src/sqliteInt.h +@@ -833,7 +833,8 @@ typedef INT16_TYPE LogEst; + # if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ +- defined(__arm__) || defined(_M_ARM64) ++ defined(__arm__) || defined(_M_ARM64) || \ ++ defined(__powerpc64__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) + # define SQLITE_BYTEORDER 1234 + # elif defined(sparc) || defined(__ppc__) + # define SQLITE_BYTEORDER 4321 +-- +2.21.1 + + +From 82ca9e5008c7431f0d06ed447f501cf40dec0b05 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 13:39:18 +0100 +Subject: [PATCH 05/13] update crashpad for ppc64 + +--- + chromium/third_party/crashpad/crashpad/compat/linux/sys/user.h | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/chromium/third_party/crashpad/crashpad/compat/linux/sys/user.h b/chromium/third_party/crashpad/crashpad/compat/linux/sys/user.h +index 6ed77a98e1c..1fd83469a0f 100644 +--- a/chromium/third_party/crashpad/crashpad/compat/linux/sys/user.h ++++ b/chromium/third_party/crashpad/crashpad/compat/linux/sys/user.h +@@ -15,6 +15,7 @@ + #ifndef CRASHPAD_COMPAT_LINUX_SYS_USER_H_ + #define CRASHPAD_COMPAT_LINUX_SYS_USER_H_ + ++#include + #include_next + + #include +-- +2.21.1 + + +From 9822b15da8d9777854a6ab5b8da8c8657d4eea43 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 13:41:50 +0100 +Subject: [PATCH 06/13] update third_party/libaom for ppc64 + +--- + chromium/third_party/libaom/BUILD.gn | 15 + + chromium/third_party/libaom/cmake_update.sh | 3 + + .../config/linux/ppc64/config/aom_config.asm | 78 + + .../config/linux/ppc64/config/aom_config.c | 13 + + .../config/linux/ppc64/config/aom_config.h | 82 + + .../config/linux/ppc64/config/aom_dsp_rtcd.h | 3128 +++++++++++++++++ + .../linux/ppc64/config/aom_scale_rtcd.h | 166 + + .../config/linux/ppc64/config/av1_rtcd.h | 896 +++++ + 8 files changed, 4381 insertions(+) + create mode 100644 chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.asm + create mode 100644 chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.c + create mode 100644 chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.h + create mode 100644 chromium/third_party/libaom/source/config/linux/ppc64/config/aom_dsp_rtcd.h + create mode 100644 chromium/third_party/libaom/source/config/linux/ppc64/config/aom_scale_rtcd.h + create mode 100644 chromium/third_party/libaom/source/config/linux/ppc64/config/av1_rtcd.h + +diff --git a/chromium/third_party/libaom/BUILD.gn b/chromium/third_party/libaom/BUILD.gn +index 2a4cde71603..c4cc2ff4022 100644 +--- a/chromium/third_party/libaom/BUILD.gn ++++ b/chromium/third_party/libaom/BUILD.gn +@@ -166,6 +166,18 @@ if (enable_av1_decoder) { + } + } + ++ if (current_cpu == "ppc64") { ++ source_set("libaom_intrinsics_vsx") { ++ configs -= [ "//build/config/compiler:chromium_code" ] ++ configs += [ "//build/config/compiler:no_chromium_code" ] ++ configs += [ ":libaom_config" ] ++ sources = [ ++ "//third_party/libaom/source/libaom/aom_ports/ppc_cpudetect.c", ++ ] ++ sources += aom_av1_common_intrin_vsx ++ } ++ } ++ + static_library("libaom") { + if (!is_debug && is_win) { + configs -= [ "//build/config/compiler:default_optimization" ] +@@ -199,6 +211,9 @@ if (enable_av1_decoder) { + cpu_arch_full == "arm-neon-cpu-detect") { + deps += [ ":libaom_intrinsics_neon" ] + } ++ if (current_cpu == "ppc64") { ++ deps += [ ":libaom_intrinsics_vsx" ] ++ } + if (is_android) { + deps += [ "//third_party/android_tools:cpu_features" ] + } +diff --git a/chromium/third_party/libaom/cmake_update.sh b/chromium/third_party/libaom/cmake_update.sh +index c4a881ff395..56d32678bd5 100755 +--- a/chromium/third_party/libaom/cmake_update.sh ++++ b/chromium/third_party/libaom/cmake_update.sh +@@ -174,6 +174,9 @@ gen_config_files linux/arm-neon-cpu-detect \ + + reset_dirs linux/arm64 + gen_config_files linux/arm64 "${toolchain}/arm64-linux-gcc.cmake ${all_platforms}" ++ ++reset_dirs linux/ppc64 ++gen_config_files linux/ppc64 "${toolchain}/ppc-linux-gcc.cmake ${all_platforms}" + ) + + update_readme +diff --git a/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.asm b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.asm +new file mode 100644 +index 00000000000..ec43beb4d0c +--- /dev/null ++++ b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.asm +@@ -0,0 +1,78 @@ ++; ++; Copyright (c) 2019, Alliance for Open Media. All rights reserved ++; ++; This source code is subject to the terms of the BSD 2 Clause License and ++; the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License ++; was not distributed with this source code in the LICENSE file, you can ++; obtain it at www.aomedia.org/license/software. If the Alliance for Open ++; Media Patent License 1.0 was not distributed with this source code in the ++; PATENTS file, you can obtain it at www.aomedia.org/license/patent. ++; ++ARCH_ARM equ 0 ++ARCH_MIPS equ 0 ++ARCH_PPC equ 1 ++ARCH_X86 equ 0 ++ARCH_X86_64 equ 0 ++CONFIG_2PASS_PARTITION_SEARCH_LVL equ 1 ++CONFIG_ACCOUNTING equ 0 ++CONFIG_ANALYZER equ 0 ++CONFIG_AV1_DECODER equ 1 ++CONFIG_AV1_ENCODER equ 0 ++CONFIG_BIG_ENDIAN equ 0 ++CONFIG_BITSTREAM_DEBUG equ 0 ++CONFIG_COEFFICIENT_RANGE_CHECKING equ 0 ++CONFIG_COLLECT_INTER_MODE_RD_STATS equ 1 ++CONFIG_COLLECT_PARTITION_STATS equ 0 ++CONFIG_COLLECT_RD_STATS equ 0 ++CONFIG_DEBUG equ 0 ++CONFIG_DENOISE equ 1 ++CONFIG_DISABLE_FULL_PIXEL_SPLIT_8X8 equ 1 ++CONFIG_DIST_8X8 equ 0 ++CONFIG_ENTROPY_STATS equ 0 ++CONFIG_FILEOPTIONS equ 1 ++CONFIG_FP_MB_STATS equ 0 ++CONFIG_GCC equ 1 ++CONFIG_GCOV equ 0 ++CONFIG_GPROF equ 0 ++CONFIG_INSPECTION equ 0 ++CONFIG_INTERNAL_STATS equ 0 ++CONFIG_INTER_STATS_ONLY equ 0 ++CONFIG_LIBYUV equ 1 ++CONFIG_LOWBITDEPTH equ 1 ++CONFIG_MAX_DECODE_PROFILE equ 0 ++CONFIG_MISMATCH_DEBUG equ 0 ++CONFIG_MULTITHREAD equ 1 ++CONFIG_NORMAL_TILE_MODE equ 1 ++CONFIG_ONE_PASS_SVM equ 0 ++CONFIG_OS_SUPPORT equ 1 ++CONFIG_PIC equ 0 ++CONFIG_RD_DEBUG equ 0 ++CONFIG_RUNTIME_CPU_DETECT equ 0 ++CONFIG_SHARED equ 0 ++CONFIG_SHARP_SETTINGS equ 0 ++CONFIG_SIZE_LIMIT equ 1 ++CONFIG_SPATIAL_RESAMPLING equ 1 ++CONFIG_SPEED_STATS equ 0 ++CONFIG_STATIC equ 1 ++CONFIG_WEBM_IO equ 1 ++DECODE_HEIGHT_LIMIT equ 16384 ++DECODE_WIDTH_LIMIT equ 16384 ++HAVE_AVX equ 0 ++HAVE_AVX2 equ 0 ++HAVE_DSPR2 equ 0 ++HAVE_FEXCEPT equ 1 ++HAVE_MIPS32 equ 0 ++HAVE_MIPS64 equ 0 ++HAVE_MMX equ 0 ++HAVE_MSA equ 0 ++HAVE_NEON equ 0 ++HAVE_PTHREAD_H equ 1 ++HAVE_SSE equ 0 ++HAVE_SSE2 equ 0 ++HAVE_SSE3 equ 0 ++HAVE_SSE4_1 equ 0 ++HAVE_SSE4_2 equ 0 ++HAVE_SSSE3 equ 0 ++HAVE_UNISTD_H equ 1 ++HAVE_VSX equ 1 ++HAVE_WXWIDGETS equ 0 +diff --git a/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.c b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.c +new file mode 100644 +index 00000000000..6db656662ef +--- /dev/null ++++ b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.c +@@ -0,0 +1,13 @@ ++/* ++ * Copyright (c) 2016, Alliance for Open Media. All rights reserved ++ * ++ * This source code is subject to the terms of the BSD 2 Clause License and ++ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License ++ * was not distributed with this source code in the LICENSE file, you can ++ * obtain it at www.aomedia.org/license/software. If the Alliance for Open ++ * Media Patent License 1.0 was not distributed with this source code in the ++ * PATENTS file, you can obtain it at www.aomedia.org/license/patent. ++ */ ++#include "aom/aom_codec.h" ++static const char* const cfg = "cmake ../source/libaom -G \"Unix Makefiles\" -DCMAKE_TOOLCHAIN_FILE=\"../source/libaom/build/cmake/toolchains/ppc-linux-gcc.cmake\" -DCONFIG_AV1_ENCODER=0 -DCONFIG_LOWBITDEPTH=1 -DCONFIG_MAX_DECODE_PROFILE=0 -DCONFIG_NORMAL_TILE_MODE=1 -DCONFIG_SIZE_LIMIT=1 -DDECODE_HEIGHT_LIMIT=16384 -DDECODE_WIDTH_LIMIT=16384"; ++const char *aom_codec_build_config(void) {return cfg;} +diff --git a/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.h b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.h +new file mode 100644 +index 00000000000..ba5b7e55be8 +--- /dev/null ++++ b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_config.h +@@ -0,0 +1,82 @@ ++/* ++ * Copyright (c) 2019, Alliance for Open Media. All rights reserved ++ * ++ * This source code is subject to the terms of the BSD 2 Clause License and ++ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License ++ * was not distributed with this source code in the LICENSE file, you can ++ * obtain it at www.aomedia.org/license/software. If the Alliance for Open ++ * Media Patent License 1.0 was not distributed with this source code in the ++ * PATENTS file, you can obtain it at www.aomedia.org/license/patent. ++ */ ++#ifndef AOM_CONFIG_H_ ++#define AOM_CONFIG_H_ ++#define ARCH_ARM 0 ++#define ARCH_MIPS 0 ++#define ARCH_PPC 1 ++#define ARCH_X86 0 ++#define ARCH_X86_64 0 ++#define CONFIG_2PASS_PARTITION_SEARCH_LVL 1 ++#define CONFIG_ACCOUNTING 0 ++#define CONFIG_ANALYZER 0 ++#define CONFIG_AV1_DECODER 1 ++#define CONFIG_AV1_ENCODER 0 ++#define CONFIG_BIG_ENDIAN 0 ++#define CONFIG_BITSTREAM_DEBUG 0 ++#define CONFIG_COEFFICIENT_RANGE_CHECKING 0 ++#define CONFIG_COLLECT_INTER_MODE_RD_STATS 1 ++#define CONFIG_COLLECT_PARTITION_STATS 0 ++#define CONFIG_COLLECT_RD_STATS 0 ++#define CONFIG_DEBUG 0 ++#define CONFIG_DENOISE 1 ++#define CONFIG_DISABLE_FULL_PIXEL_SPLIT_8X8 1 ++#define CONFIG_DIST_8X8 0 ++#define CONFIG_ENTROPY_STATS 0 ++#define CONFIG_FILEOPTIONS 1 ++#define CONFIG_FP_MB_STATS 0 ++#define CONFIG_GCC 1 ++#define CONFIG_GCOV 0 ++#define CONFIG_GPROF 0 ++#define CONFIG_INSPECTION 0 ++#define CONFIG_INTERNAL_STATS 0 ++#define CONFIG_INTER_STATS_ONLY 0 ++#define CONFIG_LIBYUV 1 ++#define CONFIG_LOWBITDEPTH 1 ++#define CONFIG_MAX_DECODE_PROFILE 0 ++#define CONFIG_MISMATCH_DEBUG 0 ++#define CONFIG_MULTITHREAD 1 ++#define CONFIG_NORMAL_TILE_MODE 1 ++#define CONFIG_ONE_PASS_SVM 0 ++#define CONFIG_OS_SUPPORT 1 ++#define CONFIG_PIC 0 ++#define CONFIG_RD_DEBUG 0 ++#define CONFIG_RUNTIME_CPU_DETECT 0 ++#define CONFIG_SHARED 0 ++#define CONFIG_SHARP_SETTINGS 0 ++#define CONFIG_SIZE_LIMIT 1 ++#define CONFIG_SPATIAL_RESAMPLING 1 ++#define CONFIG_SPEED_STATS 0 ++#define CONFIG_STATIC 1 ++#define CONFIG_WEBM_IO 1 ++#define DECODE_HEIGHT_LIMIT 16384 ++#define DECODE_WIDTH_LIMIT 16384 ++#define HAVE_AVX 0 ++#define HAVE_AVX2 0 ++#define HAVE_DSPR2 0 ++#define HAVE_FEXCEPT 1 ++#define HAVE_MIPS32 0 ++#define HAVE_MIPS64 0 ++#define HAVE_MMX 0 ++#define HAVE_MSA 0 ++#define HAVE_NEON 0 ++#define HAVE_PTHREAD_H 1 ++#define HAVE_SSE 0 ++#define HAVE_SSE2 0 ++#define HAVE_SSE3 0 ++#define HAVE_SSE4_1 0 ++#define HAVE_SSE4_2 0 ++#define HAVE_SSSE3 0 ++#define HAVE_UNISTD_H 1 ++#define HAVE_VSX 1 ++#define HAVE_WXWIDGETS 0 ++#define INLINE inline ++#endif // AOM_CONFIG_H_ +diff --git a/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_dsp_rtcd.h b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_dsp_rtcd.h +new file mode 100644 +index 00000000000..1969860e30c +--- /dev/null ++++ b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_dsp_rtcd.h +@@ -0,0 +1,3128 @@ ++// This file is generated. Do not edit. ++#ifndef AOM_DSP_RTCD_H_ ++#define AOM_DSP_RTCD_H_ ++ ++#ifdef RTCD_C ++#define RTCD_EXTERN ++#else ++#define RTCD_EXTERN extern ++#endif ++ ++/* ++ * DSP ++ */ ++ ++#include "aom/aom_integer.h" ++#include "aom_dsp/aom_dsp_common.h" ++#include "av1/common/blockd.h" ++#include "av1/common/enums.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++void aom_blend_a64_hmask_c(uint8_t* dst, ++ uint32_t dst_stride, ++ const uint8_t* src0, ++ uint32_t src0_stride, ++ const uint8_t* src1, ++ uint32_t src1_stride, ++ const uint8_t* mask, ++ int w, ++ int h); ++#define aom_blend_a64_hmask aom_blend_a64_hmask_c ++ ++void aom_blend_a64_mask_c(uint8_t* dst, ++ uint32_t dst_stride, ++ const uint8_t* src0, ++ uint32_t src0_stride, ++ const uint8_t* src1, ++ uint32_t src1_stride, ++ const uint8_t* mask, ++ uint32_t mask_stride, ++ int w, ++ int h, ++ int subx, ++ int suby); ++#define aom_blend_a64_mask aom_blend_a64_mask_c ++ ++void aom_blend_a64_vmask_c(uint8_t* dst, ++ uint32_t dst_stride, ++ const uint8_t* src0, ++ uint32_t src0_stride, ++ const uint8_t* src1, ++ uint32_t src1_stride, ++ const uint8_t* mask, ++ int w, ++ int h); ++#define aom_blend_a64_vmask aom_blend_a64_vmask_c ++ ++void aom_convolve8_horiz_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h); ++#define aom_convolve8_horiz aom_convolve8_horiz_c ++ ++void aom_convolve8_vert_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h); ++#define aom_convolve8_vert aom_convolve8_vert_c ++ ++void aom_convolve_copy_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h); ++#define aom_convolve_copy aom_convolve_copy_c ++ ++void aom_dc_128_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_16x16 aom_dc_128_predictor_16x16_c ++ ++void aom_dc_128_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_16x32 aom_dc_128_predictor_16x32_c ++ ++void aom_dc_128_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_16x4 aom_dc_128_predictor_16x4_c ++ ++void aom_dc_128_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_16x64 aom_dc_128_predictor_16x64_c ++ ++void aom_dc_128_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_16x8 aom_dc_128_predictor_16x8_c ++ ++void aom_dc_128_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_2x2 aom_dc_128_predictor_2x2_c ++ ++void aom_dc_128_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_32x16 aom_dc_128_predictor_32x16_c ++ ++void aom_dc_128_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_32x32 aom_dc_128_predictor_32x32_c ++ ++void aom_dc_128_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_32x64 aom_dc_128_predictor_32x64_c ++ ++void aom_dc_128_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_32x8 aom_dc_128_predictor_32x8_c ++ ++void aom_dc_128_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_4x16 aom_dc_128_predictor_4x16_c ++ ++void aom_dc_128_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_4x4 aom_dc_128_predictor_4x4_c ++ ++void aom_dc_128_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_4x8 aom_dc_128_predictor_4x8_c ++ ++void aom_dc_128_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_64x16 aom_dc_128_predictor_64x16_c ++ ++void aom_dc_128_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_64x32 aom_dc_128_predictor_64x32_c ++ ++void aom_dc_128_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_64x64 aom_dc_128_predictor_64x64_c ++ ++void aom_dc_128_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_8x16 aom_dc_128_predictor_8x16_c ++ ++void aom_dc_128_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_8x32 aom_dc_128_predictor_8x32_c ++ ++void aom_dc_128_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_8x4 aom_dc_128_predictor_8x4_c ++ ++void aom_dc_128_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_128_predictor_8x8 aom_dc_128_predictor_8x8_c ++ ++void aom_dc_left_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_16x16 aom_dc_left_predictor_16x16_c ++ ++void aom_dc_left_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_16x32 aom_dc_left_predictor_16x32_c ++ ++void aom_dc_left_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_16x4 aom_dc_left_predictor_16x4_c ++ ++void aom_dc_left_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_16x64 aom_dc_left_predictor_16x64_c ++ ++void aom_dc_left_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_16x8 aom_dc_left_predictor_16x8_c ++ ++void aom_dc_left_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_2x2 aom_dc_left_predictor_2x2_c ++ ++void aom_dc_left_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_32x16 aom_dc_left_predictor_32x16_c ++ ++void aom_dc_left_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_32x32 aom_dc_left_predictor_32x32_c ++ ++void aom_dc_left_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_32x64 aom_dc_left_predictor_32x64_c ++ ++void aom_dc_left_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_32x8 aom_dc_left_predictor_32x8_c ++ ++void aom_dc_left_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_4x16 aom_dc_left_predictor_4x16_c ++ ++void aom_dc_left_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_4x4 aom_dc_left_predictor_4x4_c ++ ++void aom_dc_left_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_4x8 aom_dc_left_predictor_4x8_c ++ ++void aom_dc_left_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_64x16 aom_dc_left_predictor_64x16_c ++ ++void aom_dc_left_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_64x32 aom_dc_left_predictor_64x32_c ++ ++void aom_dc_left_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_64x64 aom_dc_left_predictor_64x64_c ++ ++void aom_dc_left_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_8x16 aom_dc_left_predictor_8x16_c ++ ++void aom_dc_left_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_8x32 aom_dc_left_predictor_8x32_c ++ ++void aom_dc_left_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_8x4 aom_dc_left_predictor_8x4_c ++ ++void aom_dc_left_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_left_predictor_8x8 aom_dc_left_predictor_8x8_c ++ ++void aom_dc_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_16x16 aom_dc_predictor_16x16_c ++ ++void aom_dc_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_16x32 aom_dc_predictor_16x32_c ++ ++void aom_dc_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_16x4 aom_dc_predictor_16x4_c ++ ++void aom_dc_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_16x64 aom_dc_predictor_16x64_c ++ ++void aom_dc_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_16x8 aom_dc_predictor_16x8_c ++ ++void aom_dc_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_2x2 aom_dc_predictor_2x2_c ++ ++void aom_dc_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_32x16 aom_dc_predictor_32x16_c ++ ++void aom_dc_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_32x32 aom_dc_predictor_32x32_c ++ ++void aom_dc_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_32x64 aom_dc_predictor_32x64_c ++ ++void aom_dc_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_32x8 aom_dc_predictor_32x8_c ++ ++void aom_dc_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_4x16 aom_dc_predictor_4x16_c ++ ++void aom_dc_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_4x4 aom_dc_predictor_4x4_c ++ ++void aom_dc_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_4x8 aom_dc_predictor_4x8_c ++ ++void aom_dc_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_64x16 aom_dc_predictor_64x16_c ++ ++void aom_dc_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_64x32 aom_dc_predictor_64x32_c ++ ++void aom_dc_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_64x64 aom_dc_predictor_64x64_c ++ ++void aom_dc_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_8x16 aom_dc_predictor_8x16_c ++ ++void aom_dc_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_8x32 aom_dc_predictor_8x32_c ++ ++void aom_dc_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_8x4 aom_dc_predictor_8x4_c ++ ++void aom_dc_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_predictor_8x8 aom_dc_predictor_8x8_c ++ ++void aom_dc_top_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_16x16 aom_dc_top_predictor_16x16_c ++ ++void aom_dc_top_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_16x32 aom_dc_top_predictor_16x32_c ++ ++void aom_dc_top_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_16x4 aom_dc_top_predictor_16x4_c ++ ++void aom_dc_top_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_16x64 aom_dc_top_predictor_16x64_c ++ ++void aom_dc_top_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_16x8 aom_dc_top_predictor_16x8_c ++ ++void aom_dc_top_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_2x2 aom_dc_top_predictor_2x2_c ++ ++void aom_dc_top_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_32x16 aom_dc_top_predictor_32x16_c ++ ++void aom_dc_top_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_32x32 aom_dc_top_predictor_32x32_c ++ ++void aom_dc_top_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_32x64 aom_dc_top_predictor_32x64_c ++ ++void aom_dc_top_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_32x8 aom_dc_top_predictor_32x8_c ++ ++void aom_dc_top_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_4x16 aom_dc_top_predictor_4x16_c ++ ++void aom_dc_top_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_4x4 aom_dc_top_predictor_4x4_c ++ ++void aom_dc_top_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_4x8 aom_dc_top_predictor_4x8_c ++ ++void aom_dc_top_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_64x16 aom_dc_top_predictor_64x16_c ++ ++void aom_dc_top_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_64x32 aom_dc_top_predictor_64x32_c ++ ++void aom_dc_top_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_64x64 aom_dc_top_predictor_64x64_c ++ ++void aom_dc_top_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_8x16 aom_dc_top_predictor_8x16_c ++ ++void aom_dc_top_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_8x32 aom_dc_top_predictor_8x32_c ++ ++void aom_dc_top_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_8x4 aom_dc_top_predictor_8x4_c ++ ++void aom_dc_top_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_dc_top_predictor_8x8 aom_dc_top_predictor_8x8_c ++ ++void aom_h_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_16x16 aom_h_predictor_16x16_c ++ ++void aom_h_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_16x32 aom_h_predictor_16x32_c ++ ++void aom_h_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_16x4 aom_h_predictor_16x4_c ++ ++void aom_h_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_16x64 aom_h_predictor_16x64_c ++ ++void aom_h_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_16x8 aom_h_predictor_16x8_c ++ ++void aom_h_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_2x2 aom_h_predictor_2x2_c ++ ++void aom_h_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_32x16 aom_h_predictor_32x16_c ++ ++void aom_h_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_32x32 aom_h_predictor_32x32_c ++ ++void aom_h_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_32x64 aom_h_predictor_32x64_c ++ ++void aom_h_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_32x8 aom_h_predictor_32x8_c ++ ++void aom_h_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_4x16 aom_h_predictor_4x16_c ++ ++void aom_h_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_4x4 aom_h_predictor_4x4_c ++ ++void aom_h_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_4x8 aom_h_predictor_4x8_c ++ ++void aom_h_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_64x16 aom_h_predictor_64x16_c ++ ++void aom_h_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_64x32 aom_h_predictor_64x32_c ++ ++void aom_h_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_64x64 aom_h_predictor_64x64_c ++ ++void aom_h_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_8x16 aom_h_predictor_8x16_c ++ ++void aom_h_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_8x32 aom_h_predictor_8x32_c ++ ++void aom_h_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_8x4 aom_h_predictor_8x4_c ++ ++void aom_h_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_h_predictor_8x8 aom_h_predictor_8x8_c ++ ++void aom_highbd_blend_a64_d16_mask_c(uint8_t* dst, ++ uint32_t dst_stride, ++ const CONV_BUF_TYPE* src0, ++ uint32_t src0_stride, ++ const CONV_BUF_TYPE* src1, ++ uint32_t src1_stride, ++ const uint8_t* mask, ++ uint32_t mask_stride, ++ int w, ++ int h, ++ int subx, ++ int suby, ++ ConvolveParams* conv_params, ++ const int bd); ++#define aom_highbd_blend_a64_d16_mask aom_highbd_blend_a64_d16_mask_c ++ ++void aom_highbd_blend_a64_hmask_c(uint8_t* dst, ++ uint32_t dst_stride, ++ const uint8_t* src0, ++ uint32_t src0_stride, ++ const uint8_t* src1, ++ uint32_t src1_stride, ++ const uint8_t* mask, ++ int w, ++ int h, ++ int bd); ++#define aom_highbd_blend_a64_hmask aom_highbd_blend_a64_hmask_c ++ ++void aom_highbd_blend_a64_mask_c(uint8_t* dst, ++ uint32_t dst_stride, ++ const uint8_t* src0, ++ uint32_t src0_stride, ++ const uint8_t* src1, ++ uint32_t src1_stride, ++ const uint8_t* mask, ++ uint32_t mask_stride, ++ int w, ++ int h, ++ int subx, ++ int suby, ++ int bd); ++#define aom_highbd_blend_a64_mask aom_highbd_blend_a64_mask_c ++ ++void aom_highbd_blend_a64_vmask_c(uint8_t* dst, ++ uint32_t dst_stride, ++ const uint8_t* src0, ++ uint32_t src0_stride, ++ const uint8_t* src1, ++ uint32_t src1_stride, ++ const uint8_t* mask, ++ int w, ++ int h, ++ int bd); ++#define aom_highbd_blend_a64_vmask aom_highbd_blend_a64_vmask_c ++ ++void aom_highbd_convolve8_horiz_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ int bps); ++#define aom_highbd_convolve8_horiz aom_highbd_convolve8_horiz_c ++ ++void aom_highbd_convolve8_vert_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ int bps); ++#define aom_highbd_convolve8_vert aom_highbd_convolve8_vert_c ++ ++void aom_highbd_convolve_copy_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ int bps); ++#define aom_highbd_convolve_copy aom_highbd_convolve_copy_c ++ ++void aom_highbd_dc_128_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_16x16 aom_highbd_dc_128_predictor_16x16_c ++ ++void aom_highbd_dc_128_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_16x32 aom_highbd_dc_128_predictor_16x32_c ++ ++void aom_highbd_dc_128_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_16x4 aom_highbd_dc_128_predictor_16x4_c ++ ++void aom_highbd_dc_128_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_16x64 aom_highbd_dc_128_predictor_16x64_c ++ ++void aom_highbd_dc_128_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_16x8 aom_highbd_dc_128_predictor_16x8_c ++ ++void aom_highbd_dc_128_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_2x2 aom_highbd_dc_128_predictor_2x2_c ++ ++void aom_highbd_dc_128_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_32x16 aom_highbd_dc_128_predictor_32x16_c ++ ++void aom_highbd_dc_128_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_32x32 aom_highbd_dc_128_predictor_32x32_c ++ ++void aom_highbd_dc_128_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_32x64 aom_highbd_dc_128_predictor_32x64_c ++ ++void aom_highbd_dc_128_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_32x8 aom_highbd_dc_128_predictor_32x8_c ++ ++void aom_highbd_dc_128_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_4x16 aom_highbd_dc_128_predictor_4x16_c ++ ++void aom_highbd_dc_128_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_4x4 aom_highbd_dc_128_predictor_4x4_c ++ ++void aom_highbd_dc_128_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_4x8 aom_highbd_dc_128_predictor_4x8_c ++ ++void aom_highbd_dc_128_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_64x16 aom_highbd_dc_128_predictor_64x16_c ++ ++void aom_highbd_dc_128_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_64x32 aom_highbd_dc_128_predictor_64x32_c ++ ++void aom_highbd_dc_128_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_64x64 aom_highbd_dc_128_predictor_64x64_c ++ ++void aom_highbd_dc_128_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_8x16 aom_highbd_dc_128_predictor_8x16_c ++ ++void aom_highbd_dc_128_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_8x32 aom_highbd_dc_128_predictor_8x32_c ++ ++void aom_highbd_dc_128_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_8x4 aom_highbd_dc_128_predictor_8x4_c ++ ++void aom_highbd_dc_128_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_128_predictor_8x8 aom_highbd_dc_128_predictor_8x8_c ++ ++void aom_highbd_dc_left_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_16x16 aom_highbd_dc_left_predictor_16x16_c ++ ++void aom_highbd_dc_left_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_16x32 aom_highbd_dc_left_predictor_16x32_c ++ ++void aom_highbd_dc_left_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_16x4 aom_highbd_dc_left_predictor_16x4_c ++ ++void aom_highbd_dc_left_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_16x64 aom_highbd_dc_left_predictor_16x64_c ++ ++void aom_highbd_dc_left_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_16x8 aom_highbd_dc_left_predictor_16x8_c ++ ++void aom_highbd_dc_left_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_2x2 aom_highbd_dc_left_predictor_2x2_c ++ ++void aom_highbd_dc_left_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_32x16 aom_highbd_dc_left_predictor_32x16_c ++ ++void aom_highbd_dc_left_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_32x32 aom_highbd_dc_left_predictor_32x32_c ++ ++void aom_highbd_dc_left_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_32x64 aom_highbd_dc_left_predictor_32x64_c ++ ++void aom_highbd_dc_left_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_32x8 aom_highbd_dc_left_predictor_32x8_c ++ ++void aom_highbd_dc_left_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_4x16 aom_highbd_dc_left_predictor_4x16_c ++ ++void aom_highbd_dc_left_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_4x4 aom_highbd_dc_left_predictor_4x4_c ++ ++void aom_highbd_dc_left_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_4x8 aom_highbd_dc_left_predictor_4x8_c ++ ++void aom_highbd_dc_left_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_64x16 aom_highbd_dc_left_predictor_64x16_c ++ ++void aom_highbd_dc_left_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_64x32 aom_highbd_dc_left_predictor_64x32_c ++ ++void aom_highbd_dc_left_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_64x64 aom_highbd_dc_left_predictor_64x64_c ++ ++void aom_highbd_dc_left_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_8x16 aom_highbd_dc_left_predictor_8x16_c ++ ++void aom_highbd_dc_left_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_8x32 aom_highbd_dc_left_predictor_8x32_c ++ ++void aom_highbd_dc_left_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_8x4 aom_highbd_dc_left_predictor_8x4_c ++ ++void aom_highbd_dc_left_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_left_predictor_8x8 aom_highbd_dc_left_predictor_8x8_c ++ ++void aom_highbd_dc_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_16x16 aom_highbd_dc_predictor_16x16_c ++ ++void aom_highbd_dc_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_16x32 aom_highbd_dc_predictor_16x32_c ++ ++void aom_highbd_dc_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_16x4 aom_highbd_dc_predictor_16x4_c ++ ++void aom_highbd_dc_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_16x64 aom_highbd_dc_predictor_16x64_c ++ ++void aom_highbd_dc_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_16x8 aom_highbd_dc_predictor_16x8_c ++ ++void aom_highbd_dc_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_2x2 aom_highbd_dc_predictor_2x2_c ++ ++void aom_highbd_dc_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_32x16 aom_highbd_dc_predictor_32x16_c ++ ++void aom_highbd_dc_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_32x32 aom_highbd_dc_predictor_32x32_c ++ ++void aom_highbd_dc_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_32x64 aom_highbd_dc_predictor_32x64_c ++ ++void aom_highbd_dc_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_32x8 aom_highbd_dc_predictor_32x8_c ++ ++void aom_highbd_dc_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_4x16 aom_highbd_dc_predictor_4x16_c ++ ++void aom_highbd_dc_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_4x4 aom_highbd_dc_predictor_4x4_c ++ ++void aom_highbd_dc_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_4x8 aom_highbd_dc_predictor_4x8_c ++ ++void aom_highbd_dc_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_64x16 aom_highbd_dc_predictor_64x16_c ++ ++void aom_highbd_dc_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_64x32 aom_highbd_dc_predictor_64x32_c ++ ++void aom_highbd_dc_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_64x64 aom_highbd_dc_predictor_64x64_c ++ ++void aom_highbd_dc_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_8x16 aom_highbd_dc_predictor_8x16_c ++ ++void aom_highbd_dc_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_8x32 aom_highbd_dc_predictor_8x32_c ++ ++void aom_highbd_dc_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_8x4 aom_highbd_dc_predictor_8x4_c ++ ++void aom_highbd_dc_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_predictor_8x8 aom_highbd_dc_predictor_8x8_c ++ ++void aom_highbd_dc_top_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_16x16 aom_highbd_dc_top_predictor_16x16_c ++ ++void aom_highbd_dc_top_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_16x32 aom_highbd_dc_top_predictor_16x32_c ++ ++void aom_highbd_dc_top_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_16x4 aom_highbd_dc_top_predictor_16x4_c ++ ++void aom_highbd_dc_top_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_16x64 aom_highbd_dc_top_predictor_16x64_c ++ ++void aom_highbd_dc_top_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_16x8 aom_highbd_dc_top_predictor_16x8_c ++ ++void aom_highbd_dc_top_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_2x2 aom_highbd_dc_top_predictor_2x2_c ++ ++void aom_highbd_dc_top_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_32x16 aom_highbd_dc_top_predictor_32x16_c ++ ++void aom_highbd_dc_top_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_32x32 aom_highbd_dc_top_predictor_32x32_c ++ ++void aom_highbd_dc_top_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_32x64 aom_highbd_dc_top_predictor_32x64_c ++ ++void aom_highbd_dc_top_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_32x8 aom_highbd_dc_top_predictor_32x8_c ++ ++void aom_highbd_dc_top_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_4x16 aom_highbd_dc_top_predictor_4x16_c ++ ++void aom_highbd_dc_top_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_4x4 aom_highbd_dc_top_predictor_4x4_c ++ ++void aom_highbd_dc_top_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_4x8 aom_highbd_dc_top_predictor_4x8_c ++ ++void aom_highbd_dc_top_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_64x16 aom_highbd_dc_top_predictor_64x16_c ++ ++void aom_highbd_dc_top_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_64x32 aom_highbd_dc_top_predictor_64x32_c ++ ++void aom_highbd_dc_top_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_64x64 aom_highbd_dc_top_predictor_64x64_c ++ ++void aom_highbd_dc_top_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_8x16 aom_highbd_dc_top_predictor_8x16_c ++ ++void aom_highbd_dc_top_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_8x32 aom_highbd_dc_top_predictor_8x32_c ++ ++void aom_highbd_dc_top_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_8x4 aom_highbd_dc_top_predictor_8x4_c ++ ++void aom_highbd_dc_top_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_dc_top_predictor_8x8 aom_highbd_dc_top_predictor_8x8_c ++ ++void aom_highbd_h_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_16x16 aom_highbd_h_predictor_16x16_c ++ ++void aom_highbd_h_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_16x32 aom_highbd_h_predictor_16x32_c ++ ++void aom_highbd_h_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_16x4 aom_highbd_h_predictor_16x4_c ++ ++void aom_highbd_h_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_16x64 aom_highbd_h_predictor_16x64_c ++ ++void aom_highbd_h_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_16x8 aom_highbd_h_predictor_16x8_c ++ ++void aom_highbd_h_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_2x2 aom_highbd_h_predictor_2x2_c ++ ++void aom_highbd_h_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_32x16 aom_highbd_h_predictor_32x16_c ++ ++void aom_highbd_h_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_32x32 aom_highbd_h_predictor_32x32_c ++ ++void aom_highbd_h_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_32x64 aom_highbd_h_predictor_32x64_c ++ ++void aom_highbd_h_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_32x8 aom_highbd_h_predictor_32x8_c ++ ++void aom_highbd_h_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_4x16 aom_highbd_h_predictor_4x16_c ++ ++void aom_highbd_h_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_4x4 aom_highbd_h_predictor_4x4_c ++ ++void aom_highbd_h_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_4x8 aom_highbd_h_predictor_4x8_c ++ ++void aom_highbd_h_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_64x16 aom_highbd_h_predictor_64x16_c ++ ++void aom_highbd_h_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_64x32 aom_highbd_h_predictor_64x32_c ++ ++void aom_highbd_h_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_64x64 aom_highbd_h_predictor_64x64_c ++ ++void aom_highbd_h_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_8x16 aom_highbd_h_predictor_8x16_c ++ ++void aom_highbd_h_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_8x32 aom_highbd_h_predictor_8x32_c ++ ++void aom_highbd_h_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_8x4 aom_highbd_h_predictor_8x4_c ++ ++void aom_highbd_h_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_h_predictor_8x8 aom_highbd_h_predictor_8x8_c ++ ++void aom_highbd_lpf_horizontal_14_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh, ++ int bd); ++#define aom_highbd_lpf_horizontal_14 aom_highbd_lpf_horizontal_14_c ++ ++void aom_highbd_lpf_horizontal_14_dual_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limt1, ++ const uint8_t* thresh1, ++ int bd); ++#define aom_highbd_lpf_horizontal_14_dual aom_highbd_lpf_horizontal_14_dual_c ++ ++void aom_highbd_lpf_horizontal_4_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh, ++ int bd); ++#define aom_highbd_lpf_horizontal_4 aom_highbd_lpf_horizontal_4_c ++ ++void aom_highbd_lpf_horizontal_4_dual_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1, ++ int bd); ++#define aom_highbd_lpf_horizontal_4_dual aom_highbd_lpf_horizontal_4_dual_c ++ ++void aom_highbd_lpf_horizontal_6_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh, ++ int bd); ++#define aom_highbd_lpf_horizontal_6 aom_highbd_lpf_horizontal_6_c ++ ++void aom_highbd_lpf_horizontal_6_dual_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1, ++ int bd); ++#define aom_highbd_lpf_horizontal_6_dual aom_highbd_lpf_horizontal_6_dual_c ++ ++void aom_highbd_lpf_horizontal_8_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh, ++ int bd); ++#define aom_highbd_lpf_horizontal_8 aom_highbd_lpf_horizontal_8_c ++ ++void aom_highbd_lpf_horizontal_8_dual_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1, ++ int bd); ++#define aom_highbd_lpf_horizontal_8_dual aom_highbd_lpf_horizontal_8_dual_c ++ ++void aom_highbd_lpf_vertical_14_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh, ++ int bd); ++#define aom_highbd_lpf_vertical_14 aom_highbd_lpf_vertical_14_c ++ ++void aom_highbd_lpf_vertical_14_dual_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1, ++ int bd); ++#define aom_highbd_lpf_vertical_14_dual aom_highbd_lpf_vertical_14_dual_c ++ ++void aom_highbd_lpf_vertical_4_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh, ++ int bd); ++#define aom_highbd_lpf_vertical_4 aom_highbd_lpf_vertical_4_c ++ ++void aom_highbd_lpf_vertical_4_dual_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1, ++ int bd); ++#define aom_highbd_lpf_vertical_4_dual aom_highbd_lpf_vertical_4_dual_c ++ ++void aom_highbd_lpf_vertical_6_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh, ++ int bd); ++#define aom_highbd_lpf_vertical_6 aom_highbd_lpf_vertical_6_c ++ ++void aom_highbd_lpf_vertical_6_dual_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1, ++ int bd); ++#define aom_highbd_lpf_vertical_6_dual aom_highbd_lpf_vertical_6_dual_c ++ ++void aom_highbd_lpf_vertical_8_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh, ++ int bd); ++#define aom_highbd_lpf_vertical_8 aom_highbd_lpf_vertical_8_c ++ ++void aom_highbd_lpf_vertical_8_dual_c(uint16_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1, ++ int bd); ++#define aom_highbd_lpf_vertical_8_dual aom_highbd_lpf_vertical_8_dual_c ++ ++void aom_highbd_paeth_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_16x16 aom_highbd_paeth_predictor_16x16_c ++ ++void aom_highbd_paeth_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_16x32 aom_highbd_paeth_predictor_16x32_c ++ ++void aom_highbd_paeth_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_16x4 aom_highbd_paeth_predictor_16x4_c ++ ++void aom_highbd_paeth_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_16x64 aom_highbd_paeth_predictor_16x64_c ++ ++void aom_highbd_paeth_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_16x8 aom_highbd_paeth_predictor_16x8_c ++ ++void aom_highbd_paeth_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_2x2 aom_highbd_paeth_predictor_2x2_c ++ ++void aom_highbd_paeth_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_32x16 aom_highbd_paeth_predictor_32x16_c ++ ++void aom_highbd_paeth_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_32x32 aom_highbd_paeth_predictor_32x32_c ++ ++void aom_highbd_paeth_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_32x64 aom_highbd_paeth_predictor_32x64_c ++ ++void aom_highbd_paeth_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_32x8 aom_highbd_paeth_predictor_32x8_c ++ ++void aom_highbd_paeth_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_4x16 aom_highbd_paeth_predictor_4x16_c ++ ++void aom_highbd_paeth_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_4x4 aom_highbd_paeth_predictor_4x4_c ++ ++void aom_highbd_paeth_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_4x8 aom_highbd_paeth_predictor_4x8_c ++ ++void aom_highbd_paeth_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_64x16 aom_highbd_paeth_predictor_64x16_c ++ ++void aom_highbd_paeth_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_64x32 aom_highbd_paeth_predictor_64x32_c ++ ++void aom_highbd_paeth_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_64x64 aom_highbd_paeth_predictor_64x64_c ++ ++void aom_highbd_paeth_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_8x16 aom_highbd_paeth_predictor_8x16_c ++ ++void aom_highbd_paeth_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_8x32 aom_highbd_paeth_predictor_8x32_c ++ ++void aom_highbd_paeth_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_8x4 aom_highbd_paeth_predictor_8x4_c ++ ++void aom_highbd_paeth_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_paeth_predictor_8x8 aom_highbd_paeth_predictor_8x8_c ++ ++void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_16x16 \ ++ aom_highbd_smooth_h_predictor_16x16_c ++ ++void aom_highbd_smooth_h_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_16x32 \ ++ aom_highbd_smooth_h_predictor_16x32_c ++ ++void aom_highbd_smooth_h_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_16x4 aom_highbd_smooth_h_predictor_16x4_c ++ ++void aom_highbd_smooth_h_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_16x64 \ ++ aom_highbd_smooth_h_predictor_16x64_c ++ ++void aom_highbd_smooth_h_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_16x8 aom_highbd_smooth_h_predictor_16x8_c ++ ++void aom_highbd_smooth_h_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_2x2 aom_highbd_smooth_h_predictor_2x2_c ++ ++void aom_highbd_smooth_h_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_32x16 \ ++ aom_highbd_smooth_h_predictor_32x16_c ++ ++void aom_highbd_smooth_h_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_32x32 \ ++ aom_highbd_smooth_h_predictor_32x32_c ++ ++void aom_highbd_smooth_h_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_32x64 \ ++ aom_highbd_smooth_h_predictor_32x64_c ++ ++void aom_highbd_smooth_h_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_32x8 aom_highbd_smooth_h_predictor_32x8_c ++ ++void aom_highbd_smooth_h_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_4x16 aom_highbd_smooth_h_predictor_4x16_c ++ ++void aom_highbd_smooth_h_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_4x4 aom_highbd_smooth_h_predictor_4x4_c ++ ++void aom_highbd_smooth_h_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_4x8 aom_highbd_smooth_h_predictor_4x8_c ++ ++void aom_highbd_smooth_h_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_64x16 \ ++ aom_highbd_smooth_h_predictor_64x16_c ++ ++void aom_highbd_smooth_h_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_64x32 \ ++ aom_highbd_smooth_h_predictor_64x32_c ++ ++void aom_highbd_smooth_h_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_64x64 \ ++ aom_highbd_smooth_h_predictor_64x64_c ++ ++void aom_highbd_smooth_h_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_8x16 aom_highbd_smooth_h_predictor_8x16_c ++ ++void aom_highbd_smooth_h_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_8x32 aom_highbd_smooth_h_predictor_8x32_c ++ ++void aom_highbd_smooth_h_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_8x4 aom_highbd_smooth_h_predictor_8x4_c ++ ++void aom_highbd_smooth_h_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_h_predictor_8x8 aom_highbd_smooth_h_predictor_8x8_c ++ ++void aom_highbd_smooth_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_16x16 aom_highbd_smooth_predictor_16x16_c ++ ++void aom_highbd_smooth_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_16x32 aom_highbd_smooth_predictor_16x32_c ++ ++void aom_highbd_smooth_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_16x4 aom_highbd_smooth_predictor_16x4_c ++ ++void aom_highbd_smooth_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_16x64 aom_highbd_smooth_predictor_16x64_c ++ ++void aom_highbd_smooth_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_16x8 aom_highbd_smooth_predictor_16x8_c ++ ++void aom_highbd_smooth_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_2x2 aom_highbd_smooth_predictor_2x2_c ++ ++void aom_highbd_smooth_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_32x16 aom_highbd_smooth_predictor_32x16_c ++ ++void aom_highbd_smooth_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_32x32 aom_highbd_smooth_predictor_32x32_c ++ ++void aom_highbd_smooth_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_32x64 aom_highbd_smooth_predictor_32x64_c ++ ++void aom_highbd_smooth_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_32x8 aom_highbd_smooth_predictor_32x8_c ++ ++void aom_highbd_smooth_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_4x16 aom_highbd_smooth_predictor_4x16_c ++ ++void aom_highbd_smooth_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_4x4 aom_highbd_smooth_predictor_4x4_c ++ ++void aom_highbd_smooth_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_4x8 aom_highbd_smooth_predictor_4x8_c ++ ++void aom_highbd_smooth_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_64x16 aom_highbd_smooth_predictor_64x16_c ++ ++void aom_highbd_smooth_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_64x32 aom_highbd_smooth_predictor_64x32_c ++ ++void aom_highbd_smooth_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_64x64 aom_highbd_smooth_predictor_64x64_c ++ ++void aom_highbd_smooth_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_8x16 aom_highbd_smooth_predictor_8x16_c ++ ++void aom_highbd_smooth_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_8x32 aom_highbd_smooth_predictor_8x32_c ++ ++void aom_highbd_smooth_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_8x4 aom_highbd_smooth_predictor_8x4_c ++ ++void aom_highbd_smooth_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_predictor_8x8 aom_highbd_smooth_predictor_8x8_c ++ ++void aom_highbd_smooth_v_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_16x16 \ ++ aom_highbd_smooth_v_predictor_16x16_c ++ ++void aom_highbd_smooth_v_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_16x32 \ ++ aom_highbd_smooth_v_predictor_16x32_c ++ ++void aom_highbd_smooth_v_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_16x4 aom_highbd_smooth_v_predictor_16x4_c ++ ++void aom_highbd_smooth_v_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_16x64 \ ++ aom_highbd_smooth_v_predictor_16x64_c ++ ++void aom_highbd_smooth_v_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_16x8 aom_highbd_smooth_v_predictor_16x8_c ++ ++void aom_highbd_smooth_v_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_2x2 aom_highbd_smooth_v_predictor_2x2_c ++ ++void aom_highbd_smooth_v_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_32x16 \ ++ aom_highbd_smooth_v_predictor_32x16_c ++ ++void aom_highbd_smooth_v_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_32x32 \ ++ aom_highbd_smooth_v_predictor_32x32_c ++ ++void aom_highbd_smooth_v_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_32x64 \ ++ aom_highbd_smooth_v_predictor_32x64_c ++ ++void aom_highbd_smooth_v_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_32x8 aom_highbd_smooth_v_predictor_32x8_c ++ ++void aom_highbd_smooth_v_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_4x16 aom_highbd_smooth_v_predictor_4x16_c ++ ++void aom_highbd_smooth_v_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_4x4 aom_highbd_smooth_v_predictor_4x4_c ++ ++void aom_highbd_smooth_v_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_4x8 aom_highbd_smooth_v_predictor_4x8_c ++ ++void aom_highbd_smooth_v_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_64x16 \ ++ aom_highbd_smooth_v_predictor_64x16_c ++ ++void aom_highbd_smooth_v_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_64x32 \ ++ aom_highbd_smooth_v_predictor_64x32_c ++ ++void aom_highbd_smooth_v_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_64x64 \ ++ aom_highbd_smooth_v_predictor_64x64_c ++ ++void aom_highbd_smooth_v_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_8x16 aom_highbd_smooth_v_predictor_8x16_c ++ ++void aom_highbd_smooth_v_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_8x32 aom_highbd_smooth_v_predictor_8x32_c ++ ++void aom_highbd_smooth_v_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_8x4 aom_highbd_smooth_v_predictor_8x4_c ++ ++void aom_highbd_smooth_v_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_smooth_v_predictor_8x8 aom_highbd_smooth_v_predictor_8x8_c ++ ++void aom_highbd_v_predictor_16x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_16x16 aom_highbd_v_predictor_16x16_c ++ ++void aom_highbd_v_predictor_16x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_16x32 aom_highbd_v_predictor_16x32_c ++ ++void aom_highbd_v_predictor_16x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_16x4 aom_highbd_v_predictor_16x4_c ++ ++void aom_highbd_v_predictor_16x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_16x64 aom_highbd_v_predictor_16x64_c ++ ++void aom_highbd_v_predictor_16x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_16x8 aom_highbd_v_predictor_16x8_c ++ ++void aom_highbd_v_predictor_2x2_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_2x2 aom_highbd_v_predictor_2x2_c ++ ++void aom_highbd_v_predictor_32x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_32x16 aom_highbd_v_predictor_32x16_c ++ ++void aom_highbd_v_predictor_32x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_32x32 aom_highbd_v_predictor_32x32_c ++ ++void aom_highbd_v_predictor_32x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_32x64 aom_highbd_v_predictor_32x64_c ++ ++void aom_highbd_v_predictor_32x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_32x8 aom_highbd_v_predictor_32x8_c ++ ++void aom_highbd_v_predictor_4x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_4x16 aom_highbd_v_predictor_4x16_c ++ ++void aom_highbd_v_predictor_4x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_4x4 aom_highbd_v_predictor_4x4_c ++ ++void aom_highbd_v_predictor_4x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_4x8 aom_highbd_v_predictor_4x8_c ++ ++void aom_highbd_v_predictor_64x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_64x16 aom_highbd_v_predictor_64x16_c ++ ++void aom_highbd_v_predictor_64x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_64x32 aom_highbd_v_predictor_64x32_c ++ ++void aom_highbd_v_predictor_64x64_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_64x64 aom_highbd_v_predictor_64x64_c ++ ++void aom_highbd_v_predictor_8x16_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_8x16 aom_highbd_v_predictor_8x16_c ++ ++void aom_highbd_v_predictor_8x32_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_8x32 aom_highbd_v_predictor_8x32_c ++ ++void aom_highbd_v_predictor_8x4_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_8x4 aom_highbd_v_predictor_8x4_c ++ ++void aom_highbd_v_predictor_8x8_c(uint16_t* dst, ++ ptrdiff_t y_stride, ++ const uint16_t* above, ++ const uint16_t* left, ++ int bd); ++#define aom_highbd_v_predictor_8x8 aom_highbd_v_predictor_8x8_c ++ ++void aom_lowbd_blend_a64_d16_mask_c(uint8_t* dst, ++ uint32_t dst_stride, ++ const CONV_BUF_TYPE* src0, ++ uint32_t src0_stride, ++ const CONV_BUF_TYPE* src1, ++ uint32_t src1_stride, ++ const uint8_t* mask, ++ uint32_t mask_stride, ++ int w, ++ int h, ++ int subx, ++ int suby, ++ ConvolveParams* conv_params); ++#define aom_lowbd_blend_a64_d16_mask aom_lowbd_blend_a64_d16_mask_c ++ ++void aom_lpf_horizontal_14_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh); ++#define aom_lpf_horizontal_14 aom_lpf_horizontal_14_c ++ ++void aom_lpf_horizontal_14_dual_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1); ++#define aom_lpf_horizontal_14_dual aom_lpf_horizontal_14_dual_c ++ ++void aom_lpf_horizontal_4_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh); ++#define aom_lpf_horizontal_4 aom_lpf_horizontal_4_c ++ ++void aom_lpf_horizontal_4_dual_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1); ++#define aom_lpf_horizontal_4_dual aom_lpf_horizontal_4_dual_c ++ ++void aom_lpf_horizontal_6_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh); ++#define aom_lpf_horizontal_6 aom_lpf_horizontal_6_c ++ ++void aom_lpf_horizontal_6_dual_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1); ++#define aom_lpf_horizontal_6_dual aom_lpf_horizontal_6_dual_c ++ ++void aom_lpf_horizontal_8_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh); ++#define aom_lpf_horizontal_8 aom_lpf_horizontal_8_c ++ ++void aom_lpf_horizontal_8_dual_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1); ++#define aom_lpf_horizontal_8_dual aom_lpf_horizontal_8_dual_c ++ ++void aom_lpf_vertical_14_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh); ++#define aom_lpf_vertical_14 aom_lpf_vertical_14_c ++ ++void aom_lpf_vertical_14_dual_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1); ++#define aom_lpf_vertical_14_dual aom_lpf_vertical_14_dual_c ++ ++void aom_lpf_vertical_4_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh); ++#define aom_lpf_vertical_4 aom_lpf_vertical_4_c ++ ++void aom_lpf_vertical_4_dual_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1); ++#define aom_lpf_vertical_4_dual aom_lpf_vertical_4_dual_c ++ ++void aom_lpf_vertical_6_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh); ++#define aom_lpf_vertical_6 aom_lpf_vertical_6_c ++ ++void aom_lpf_vertical_6_dual_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1); ++#define aom_lpf_vertical_6_dual aom_lpf_vertical_6_dual_c ++ ++void aom_lpf_vertical_8_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit, ++ const uint8_t* limit, ++ const uint8_t* thresh); ++#define aom_lpf_vertical_8 aom_lpf_vertical_8_c ++ ++void aom_lpf_vertical_8_dual_c(uint8_t* s, ++ int pitch, ++ const uint8_t* blimit0, ++ const uint8_t* limit0, ++ const uint8_t* thresh0, ++ const uint8_t* blimit1, ++ const uint8_t* limit1, ++ const uint8_t* thresh1); ++#define aom_lpf_vertical_8_dual aom_lpf_vertical_8_dual_c ++ ++void aom_paeth_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_16x16 aom_paeth_predictor_16x16_c ++ ++void aom_paeth_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_16x32 aom_paeth_predictor_16x32_c ++ ++void aom_paeth_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_16x4 aom_paeth_predictor_16x4_c ++ ++void aom_paeth_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_16x64 aom_paeth_predictor_16x64_c ++ ++void aom_paeth_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_16x8 aom_paeth_predictor_16x8_c ++ ++void aom_paeth_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_2x2 aom_paeth_predictor_2x2_c ++ ++void aom_paeth_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_32x16 aom_paeth_predictor_32x16_c ++ ++void aom_paeth_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_32x32 aom_paeth_predictor_32x32_c ++ ++void aom_paeth_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_32x64 aom_paeth_predictor_32x64_c ++ ++void aom_paeth_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_32x8 aom_paeth_predictor_32x8_c ++ ++void aom_paeth_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_4x16 aom_paeth_predictor_4x16_c ++ ++void aom_paeth_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_4x4 aom_paeth_predictor_4x4_c ++ ++void aom_paeth_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_4x8 aom_paeth_predictor_4x8_c ++ ++void aom_paeth_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_64x16 aom_paeth_predictor_64x16_c ++ ++void aom_paeth_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_64x32 aom_paeth_predictor_64x32_c ++ ++void aom_paeth_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_64x64 aom_paeth_predictor_64x64_c ++ ++void aom_paeth_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_8x16 aom_paeth_predictor_8x16_c ++ ++void aom_paeth_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_8x32 aom_paeth_predictor_8x32_c ++ ++void aom_paeth_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_8x4 aom_paeth_predictor_8x4_c ++ ++void aom_paeth_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_paeth_predictor_8x8 aom_paeth_predictor_8x8_c ++ ++void aom_smooth_h_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_16x16 aom_smooth_h_predictor_16x16_c ++ ++void aom_smooth_h_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_16x32 aom_smooth_h_predictor_16x32_c ++ ++void aom_smooth_h_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_16x4 aom_smooth_h_predictor_16x4_c ++ ++void aom_smooth_h_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_16x64 aom_smooth_h_predictor_16x64_c ++ ++void aom_smooth_h_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_16x8 aom_smooth_h_predictor_16x8_c ++ ++void aom_smooth_h_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_2x2 aom_smooth_h_predictor_2x2_c ++ ++void aom_smooth_h_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_32x16 aom_smooth_h_predictor_32x16_c ++ ++void aom_smooth_h_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_32x32 aom_smooth_h_predictor_32x32_c ++ ++void aom_smooth_h_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_32x64 aom_smooth_h_predictor_32x64_c ++ ++void aom_smooth_h_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_32x8 aom_smooth_h_predictor_32x8_c ++ ++void aom_smooth_h_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_4x16 aom_smooth_h_predictor_4x16_c ++ ++void aom_smooth_h_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_4x4 aom_smooth_h_predictor_4x4_c ++ ++void aom_smooth_h_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_4x8 aom_smooth_h_predictor_4x8_c ++ ++void aom_smooth_h_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_64x16 aom_smooth_h_predictor_64x16_c ++ ++void aom_smooth_h_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_64x32 aom_smooth_h_predictor_64x32_c ++ ++void aom_smooth_h_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_64x64 aom_smooth_h_predictor_64x64_c ++ ++void aom_smooth_h_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_8x16 aom_smooth_h_predictor_8x16_c ++ ++void aom_smooth_h_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_8x32 aom_smooth_h_predictor_8x32_c ++ ++void aom_smooth_h_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_8x4 aom_smooth_h_predictor_8x4_c ++ ++void aom_smooth_h_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_h_predictor_8x8 aom_smooth_h_predictor_8x8_c ++ ++void aom_smooth_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_16x16 aom_smooth_predictor_16x16_c ++ ++void aom_smooth_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_16x32 aom_smooth_predictor_16x32_c ++ ++void aom_smooth_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_16x4 aom_smooth_predictor_16x4_c ++ ++void aom_smooth_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_16x64 aom_smooth_predictor_16x64_c ++ ++void aom_smooth_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_16x8 aom_smooth_predictor_16x8_c ++ ++void aom_smooth_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_2x2 aom_smooth_predictor_2x2_c ++ ++void aom_smooth_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_32x16 aom_smooth_predictor_32x16_c ++ ++void aom_smooth_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_32x32 aom_smooth_predictor_32x32_c ++ ++void aom_smooth_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_32x64 aom_smooth_predictor_32x64_c ++ ++void aom_smooth_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_32x8 aom_smooth_predictor_32x8_c ++ ++void aom_smooth_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_4x16 aom_smooth_predictor_4x16_c ++ ++void aom_smooth_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_4x4 aom_smooth_predictor_4x4_c ++ ++void aom_smooth_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_4x8 aom_smooth_predictor_4x8_c ++ ++void aom_smooth_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_64x16 aom_smooth_predictor_64x16_c ++ ++void aom_smooth_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_64x32 aom_smooth_predictor_64x32_c ++ ++void aom_smooth_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_64x64 aom_smooth_predictor_64x64_c ++ ++void aom_smooth_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_8x16 aom_smooth_predictor_8x16_c ++ ++void aom_smooth_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_8x32 aom_smooth_predictor_8x32_c ++ ++void aom_smooth_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_8x4 aom_smooth_predictor_8x4_c ++ ++void aom_smooth_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_predictor_8x8 aom_smooth_predictor_8x8_c ++ ++void aom_smooth_v_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_16x16 aom_smooth_v_predictor_16x16_c ++ ++void aom_smooth_v_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_16x32 aom_smooth_v_predictor_16x32_c ++ ++void aom_smooth_v_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_16x4 aom_smooth_v_predictor_16x4_c ++ ++void aom_smooth_v_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_16x64 aom_smooth_v_predictor_16x64_c ++ ++void aom_smooth_v_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_16x8 aom_smooth_v_predictor_16x8_c ++ ++void aom_smooth_v_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_2x2 aom_smooth_v_predictor_2x2_c ++ ++void aom_smooth_v_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_32x16 aom_smooth_v_predictor_32x16_c ++ ++void aom_smooth_v_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_32x32 aom_smooth_v_predictor_32x32_c ++ ++void aom_smooth_v_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_32x64 aom_smooth_v_predictor_32x64_c ++ ++void aom_smooth_v_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_32x8 aom_smooth_v_predictor_32x8_c ++ ++void aom_smooth_v_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_4x16 aom_smooth_v_predictor_4x16_c ++ ++void aom_smooth_v_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_4x4 aom_smooth_v_predictor_4x4_c ++ ++void aom_smooth_v_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_4x8 aom_smooth_v_predictor_4x8_c ++ ++void aom_smooth_v_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_64x16 aom_smooth_v_predictor_64x16_c ++ ++void aom_smooth_v_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_64x32 aom_smooth_v_predictor_64x32_c ++ ++void aom_smooth_v_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_64x64 aom_smooth_v_predictor_64x64_c ++ ++void aom_smooth_v_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_8x16 aom_smooth_v_predictor_8x16_c ++ ++void aom_smooth_v_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_8x32 aom_smooth_v_predictor_8x32_c ++ ++void aom_smooth_v_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_8x4 aom_smooth_v_predictor_8x4_c ++ ++void aom_smooth_v_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_smooth_v_predictor_8x8 aom_smooth_v_predictor_8x8_c ++ ++void aom_v_predictor_16x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_16x16 aom_v_predictor_16x16_c ++ ++void aom_v_predictor_16x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_16x32 aom_v_predictor_16x32_c ++ ++void aom_v_predictor_16x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_16x4 aom_v_predictor_16x4_c ++ ++void aom_v_predictor_16x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_16x64 aom_v_predictor_16x64_c ++ ++void aom_v_predictor_16x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_16x8 aom_v_predictor_16x8_c ++ ++void aom_v_predictor_2x2_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_2x2 aom_v_predictor_2x2_c ++ ++void aom_v_predictor_32x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_32x16 aom_v_predictor_32x16_c ++ ++void aom_v_predictor_32x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_32x32 aom_v_predictor_32x32_c ++ ++void aom_v_predictor_32x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_32x64 aom_v_predictor_32x64_c ++ ++void aom_v_predictor_32x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_32x8 aom_v_predictor_32x8_c ++ ++void aom_v_predictor_4x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_4x16 aom_v_predictor_4x16_c ++ ++void aom_v_predictor_4x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_4x4 aom_v_predictor_4x4_c ++ ++void aom_v_predictor_4x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_4x8 aom_v_predictor_4x8_c ++ ++void aom_v_predictor_64x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_64x16 aom_v_predictor_64x16_c ++ ++void aom_v_predictor_64x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_64x32 aom_v_predictor_64x32_c ++ ++void aom_v_predictor_64x64_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_64x64 aom_v_predictor_64x64_c ++ ++void aom_v_predictor_8x16_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_8x16 aom_v_predictor_8x16_c ++ ++void aom_v_predictor_8x32_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_8x32 aom_v_predictor_8x32_c ++ ++void aom_v_predictor_8x4_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_8x4 aom_v_predictor_8x4_c ++ ++void aom_v_predictor_8x8_c(uint8_t* dst, ++ ptrdiff_t y_stride, ++ const uint8_t* above, ++ const uint8_t* left); ++#define aom_v_predictor_8x8 aom_v_predictor_8x8_c ++ ++void aom_dsp_rtcd(void); ++ ++#include "config/aom_config.h" ++ ++#ifdef RTCD_C ++#include "aom_ports/ppc.h" ++static void setup_rtcd_internal(void) { ++ int flags = ppc_simd_caps(); ++ ++ (void)flags; ++} ++#endif ++ ++#ifdef __cplusplus ++} // extern "C" ++#endif ++ ++#endif +diff --git a/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_scale_rtcd.h b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_scale_rtcd.h +new file mode 100644 +index 00000000000..084b2e062f4 +--- /dev/null ++++ b/chromium/third_party/libaom/source/config/linux/ppc64/config/aom_scale_rtcd.h +@@ -0,0 +1,166 @@ ++// This file is generated. Do not edit. ++#ifndef AOM_SCALE_RTCD_H_ ++#define AOM_SCALE_RTCD_H_ ++ ++#ifdef RTCD_C ++#define RTCD_EXTERN ++#else ++#define RTCD_EXTERN extern ++#endif ++ ++struct yv12_buffer_config; ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++void aom_extend_frame_borders_c(struct yv12_buffer_config* ybf, ++ const int num_planes); ++#define aom_extend_frame_borders aom_extend_frame_borders_c ++ ++void aom_extend_frame_borders_y_c(struct yv12_buffer_config* ybf); ++#define aom_extend_frame_borders_y aom_extend_frame_borders_y_c ++ ++void aom_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf, ++ const int num_planes); ++#define aom_extend_frame_inner_borders aom_extend_frame_inner_borders_c ++ ++void aom_horizontal_line_2_1_scale_c(const unsigned char* source, ++ unsigned int source_width, ++ unsigned char* dest, ++ unsigned int dest_width); ++#define aom_horizontal_line_2_1_scale aom_horizontal_line_2_1_scale_c ++ ++void aom_horizontal_line_5_3_scale_c(const unsigned char* source, ++ unsigned int source_width, ++ unsigned char* dest, ++ unsigned int dest_width); ++#define aom_horizontal_line_5_3_scale aom_horizontal_line_5_3_scale_c ++ ++void aom_horizontal_line_5_4_scale_c(const unsigned char* source, ++ unsigned int source_width, ++ unsigned char* dest, ++ unsigned int dest_width); ++#define aom_horizontal_line_5_4_scale aom_horizontal_line_5_4_scale_c ++ ++void aom_vertical_band_2_1_scale_c(unsigned char* source, ++ int src_pitch, ++ unsigned char* dest, ++ int dest_pitch, ++ unsigned int dest_width); ++#define aom_vertical_band_2_1_scale aom_vertical_band_2_1_scale_c ++ ++void aom_vertical_band_2_1_scale_i_c(unsigned char* source, ++ int src_pitch, ++ unsigned char* dest, ++ int dest_pitch, ++ unsigned int dest_width); ++#define aom_vertical_band_2_1_scale_i aom_vertical_band_2_1_scale_i_c ++ ++void aom_vertical_band_5_3_scale_c(unsigned char* source, ++ int src_pitch, ++ unsigned char* dest, ++ int dest_pitch, ++ unsigned int dest_width); ++#define aom_vertical_band_5_3_scale aom_vertical_band_5_3_scale_c ++ ++void aom_vertical_band_5_4_scale_c(unsigned char* source, ++ int src_pitch, ++ unsigned char* dest, ++ int dest_pitch, ++ unsigned int dest_width); ++#define aom_vertical_band_5_4_scale aom_vertical_band_5_4_scale_c ++ ++void aom_yv12_copy_frame_c(const struct yv12_buffer_config* src_bc, ++ struct yv12_buffer_config* dst_bc, ++ const int num_planes); ++#define aom_yv12_copy_frame aom_yv12_copy_frame_c ++ ++void aom_yv12_copy_u_c(const struct yv12_buffer_config* src_bc, ++ struct yv12_buffer_config* dst_bc); ++#define aom_yv12_copy_u aom_yv12_copy_u_c ++ ++void aom_yv12_copy_v_c(const struct yv12_buffer_config* src_bc, ++ struct yv12_buffer_config* dst_bc); ++#define aom_yv12_copy_v aom_yv12_copy_v_c ++ ++void aom_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc, ++ struct yv12_buffer_config* dst_ybc); ++#define aom_yv12_copy_y aom_yv12_copy_y_c ++ ++void aom_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf, ++ const int num_planes); ++#define aom_yv12_extend_frame_borders aom_yv12_extend_frame_borders_c ++ ++void aom_yv12_partial_coloc_copy_u_c(const struct yv12_buffer_config* src_bc, ++ struct yv12_buffer_config* dst_bc, ++ int hstart, ++ int hend, ++ int vstart, ++ int vend); ++#define aom_yv12_partial_coloc_copy_u aom_yv12_partial_coloc_copy_u_c ++ ++void aom_yv12_partial_coloc_copy_v_c(const struct yv12_buffer_config* src_bc, ++ struct yv12_buffer_config* dst_bc, ++ int hstart, ++ int hend, ++ int vstart, ++ int vend); ++#define aom_yv12_partial_coloc_copy_v aom_yv12_partial_coloc_copy_v_c ++ ++void aom_yv12_partial_coloc_copy_y_c(const struct yv12_buffer_config* src_ybc, ++ struct yv12_buffer_config* dst_ybc, ++ int hstart, ++ int hend, ++ int vstart, ++ int vend); ++#define aom_yv12_partial_coloc_copy_y aom_yv12_partial_coloc_copy_y_c ++ ++void aom_yv12_partial_copy_u_c(const struct yv12_buffer_config* src_bc, ++ int hstart1, ++ int hend1, ++ int vstart1, ++ int vend1, ++ struct yv12_buffer_config* dst_bc, ++ int hstart2, ++ int vstart2); ++#define aom_yv12_partial_copy_u aom_yv12_partial_copy_u_c ++ ++void aom_yv12_partial_copy_v_c(const struct yv12_buffer_config* src_bc, ++ int hstart1, ++ int hend1, ++ int vstart1, ++ int vend1, ++ struct yv12_buffer_config* dst_bc, ++ int hstart2, ++ int vstart2); ++#define aom_yv12_partial_copy_v aom_yv12_partial_copy_v_c ++ ++void aom_yv12_partial_copy_y_c(const struct yv12_buffer_config* src_ybc, ++ int hstart1, ++ int hend1, ++ int vstart1, ++ int vend1, ++ struct yv12_buffer_config* dst_ybc, ++ int hstart2, ++ int vstart2); ++#define aom_yv12_partial_copy_y aom_yv12_partial_copy_y_c ++ ++void aom_scale_rtcd(void); ++ ++#include "config/aom_config.h" ++ ++#ifdef RTCD_C ++#include "aom_ports/ppc.h" ++static void setup_rtcd_internal(void) { ++ int flags = ppc_simd_caps(); ++ ++ (void)flags; ++} ++#endif ++ ++#ifdef __cplusplus ++} // extern "C" ++#endif ++ ++#endif +diff --git a/chromium/third_party/libaom/source/config/linux/ppc64/config/av1_rtcd.h b/chromium/third_party/libaom/source/config/linux/ppc64/config/av1_rtcd.h +new file mode 100644 +index 00000000000..350fb916c1f +--- /dev/null ++++ b/chromium/third_party/libaom/source/config/linux/ppc64/config/av1_rtcd.h +@@ -0,0 +1,896 @@ ++// This file is generated. Do not edit. ++#ifndef AV1_RTCD_H_ ++#define AV1_RTCD_H_ ++ ++#ifdef RTCD_C ++#define RTCD_EXTERN ++#else ++#define RTCD_EXTERN extern ++#endif ++ ++/* ++ * AV1 ++ */ ++ ++#include "aom/aom_integer.h" ++#include "aom_dsp/txfm_common.h" ++#include "av1/common/av1_txfm.h" ++#include "av1/common/common.h" ++#include "av1/common/convolve.h" ++#include "av1/common/enums.h" ++#include "av1/common/filter.h" ++#include "av1/common/odintrin.h" ++#include "av1/common/quant_common.h" ++#include "av1/common/restoration.h" ++ ++struct macroblockd; ++ ++/* Encoder forward decls */ ++struct macroblock; ++struct txfm_param; ++struct aom_variance_vtable; ++struct search_site_config; ++struct yv12_buffer_config; ++struct NN_CONFIG; ++typedef struct NN_CONFIG NN_CONFIG; ++ ++/* Function pointers return by CfL functions */ ++typedef void (*cfl_subsample_lbd_fn)(const uint8_t* input, ++ int input_stride, ++ uint16_t* output_q3); ++ ++typedef void (*cfl_subsample_hbd_fn)(const uint16_t* input, ++ int input_stride, ++ uint16_t* output_q3); ++ ++typedef void (*cfl_subtract_average_fn)(const uint16_t* src, int16_t* dst); ++ ++typedef void (*cfl_predict_lbd_fn)(const int16_t* src, ++ uint8_t* dst, ++ int dst_stride, ++ int alpha_q3); ++ ++typedef void (*cfl_predict_hbd_fn)(const int16_t* src, ++ uint16_t* dst, ++ int dst_stride, ++ int alpha_q3, ++ int bd); ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++void apply_selfguided_restoration_c(const uint8_t* dat, ++ int width, ++ int height, ++ int stride, ++ int eps, ++ const int* xqd, ++ uint8_t* dst, ++ int dst_stride, ++ int32_t* tmpbuf, ++ int bit_depth, ++ int highbd); ++#define apply_selfguided_restoration apply_selfguided_restoration_c ++ ++void av1_build_compound_diffwtd_mask_c(uint8_t* mask, ++ DIFFWTD_MASK_TYPE mask_type, ++ const uint8_t* src0, ++ int src0_stride, ++ const uint8_t* src1, ++ int src1_stride, ++ int h, ++ int w); ++#define av1_build_compound_diffwtd_mask av1_build_compound_diffwtd_mask_c ++ ++void av1_build_compound_diffwtd_mask_d16_c(uint8_t* mask, ++ DIFFWTD_MASK_TYPE mask_type, ++ const CONV_BUF_TYPE* src0, ++ int src0_stride, ++ const CONV_BUF_TYPE* src1, ++ int src1_stride, ++ int h, ++ int w, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_build_compound_diffwtd_mask_d16 \ ++ av1_build_compound_diffwtd_mask_d16_c ++ ++void av1_build_compound_diffwtd_mask_highbd_c(uint8_t* mask, ++ DIFFWTD_MASK_TYPE mask_type, ++ const uint8_t* src0, ++ int src0_stride, ++ const uint8_t* src1, ++ int src1_stride, ++ int h, ++ int w, ++ int bd); ++#define av1_build_compound_diffwtd_mask_highbd \ ++ av1_build_compound_diffwtd_mask_highbd_c ++ ++void av1_convolve_2d_copy_sr_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params); ++#define av1_convolve_2d_copy_sr av1_convolve_2d_copy_sr_c ++ ++void av1_convolve_2d_scale_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_qn, ++ const int x_step_qn, ++ const int subpel_y_q4, ++ const int y_step_qn, ++ ConvolveParams* conv_params); ++#define av1_convolve_2d_scale av1_convolve_2d_scale_c ++ ++void av1_convolve_2d_sr_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params); ++#define av1_convolve_2d_sr av1_convolve_2d_sr_c ++ ++void av1_convolve_horiz_rs_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const int16_t* x_filters, ++ int x0_qn, ++ int x_step_qn); ++#define av1_convolve_horiz_rs av1_convolve_horiz_rs_c ++ ++void av1_convolve_x_sr_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params); ++#define av1_convolve_x_sr av1_convolve_x_sr_c ++ ++void av1_convolve_y_sr_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params); ++#define av1_convolve_y_sr av1_convolve_y_sr_c ++ ++void av1_dist_wtd_convolve_2d_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params); ++#define av1_dist_wtd_convolve_2d av1_dist_wtd_convolve_2d_c ++ ++void av1_dist_wtd_convolve_2d_copy_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params); ++#define av1_dist_wtd_convolve_2d_copy av1_dist_wtd_convolve_2d_copy_c ++ ++void av1_dist_wtd_convolve_x_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params); ++#define av1_dist_wtd_convolve_x av1_dist_wtd_convolve_x_c ++ ++void av1_dist_wtd_convolve_y_c(const uint8_t* src, ++ int src_stride, ++ uint8_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params); ++#define av1_dist_wtd_convolve_y av1_dist_wtd_convolve_y_c ++ ++void av1_dr_prediction_z1_c(uint8_t* dst, ++ ptrdiff_t stride, ++ int bw, ++ int bh, ++ const uint8_t* above, ++ const uint8_t* left, ++ int upsample_above, ++ int dx, ++ int dy); ++#define av1_dr_prediction_z1 av1_dr_prediction_z1_c ++ ++void av1_dr_prediction_z2_c(uint8_t* dst, ++ ptrdiff_t stride, ++ int bw, ++ int bh, ++ const uint8_t* above, ++ const uint8_t* left, ++ int upsample_above, ++ int upsample_left, ++ int dx, ++ int dy); ++#define av1_dr_prediction_z2 av1_dr_prediction_z2_c ++ ++void av1_dr_prediction_z3_c(uint8_t* dst, ++ ptrdiff_t stride, ++ int bw, ++ int bh, ++ const uint8_t* above, ++ const uint8_t* left, ++ int upsample_left, ++ int dx, ++ int dy); ++#define av1_dr_prediction_z3 av1_dr_prediction_z3_c ++ ++void av1_filter_intra_edge_c(uint8_t* p, int sz, int strength); ++#define av1_filter_intra_edge av1_filter_intra_edge_c ++ ++void av1_filter_intra_edge_high_c(uint16_t* p, int sz, int strength); ++#define av1_filter_intra_edge_high av1_filter_intra_edge_high_c ++ ++void av1_filter_intra_predictor_c(uint8_t* dst, ++ ptrdiff_t stride, ++ TX_SIZE tx_size, ++ const uint8_t* above, ++ const uint8_t* left, ++ int mode); ++#define av1_filter_intra_predictor av1_filter_intra_predictor_c ++ ++void av1_highbd_convolve8_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ int bps); ++#define av1_highbd_convolve8 av1_highbd_convolve8_c ++ ++void av1_highbd_convolve8_horiz_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ int bps); ++#define av1_highbd_convolve8_horiz av1_highbd_convolve8_horiz_c ++ ++void av1_highbd_convolve8_vert_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ int bps); ++#define av1_highbd_convolve8_vert av1_highbd_convolve8_vert_c ++ ++void av1_highbd_convolve_2d_copy_sr_c(const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_convolve_2d_copy_sr av1_highbd_convolve_2d_copy_sr_c ++ ++void av1_highbd_convolve_2d_scale_c(const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int x_step_qn, ++ const int subpel_y_q4, ++ const int y_step_qn, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_convolve_2d_scale av1_highbd_convolve_2d_scale_c ++ ++void av1_highbd_convolve_2d_sr_c(const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_convolve_2d_sr av1_highbd_convolve_2d_sr_c ++ ++void av1_highbd_convolve_avg_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ int bps); ++#define av1_highbd_convolve_avg av1_highbd_convolve_avg_c ++ ++void av1_highbd_convolve_copy_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ int bps); ++#define av1_highbd_convolve_copy av1_highbd_convolve_copy_c ++ ++void av1_highbd_convolve_horiz_rs_c(const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const int16_t* x_filters, ++ int x0_qn, ++ int x_step_qn, ++ int bd); ++#define av1_highbd_convolve_horiz_rs av1_highbd_convolve_horiz_rs_c ++ ++void av1_highbd_convolve_x_sr_c(const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_convolve_x_sr av1_highbd_convolve_x_sr_c ++ ++void av1_highbd_convolve_y_sr_c(const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_convolve_y_sr av1_highbd_convolve_y_sr_c ++ ++void av1_highbd_dist_wtd_convolve_2d_c( ++ const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_dist_wtd_convolve_2d av1_highbd_dist_wtd_convolve_2d_c ++ ++void av1_highbd_dist_wtd_convolve_2d_copy_c( ++ const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_dist_wtd_convolve_2d_copy \ ++ av1_highbd_dist_wtd_convolve_2d_copy_c ++ ++void av1_highbd_dist_wtd_convolve_x_c(const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_dist_wtd_convolve_x av1_highbd_dist_wtd_convolve_x_c ++ ++void av1_highbd_dist_wtd_convolve_y_c(const uint16_t* src, ++ int src_stride, ++ uint16_t* dst, ++ int dst_stride, ++ int w, ++ int h, ++ const InterpFilterParams* filter_params_x, ++ const InterpFilterParams* filter_params_y, ++ const int subpel_x_q4, ++ const int subpel_y_q4, ++ ConvolveParams* conv_params, ++ int bd); ++#define av1_highbd_dist_wtd_convolve_y av1_highbd_dist_wtd_convolve_y_c ++ ++void av1_highbd_dr_prediction_z1_c(uint16_t* dst, ++ ptrdiff_t stride, ++ int bw, ++ int bh, ++ const uint16_t* above, ++ const uint16_t* left, ++ int upsample_above, ++ int dx, ++ int dy, ++ int bd); ++#define av1_highbd_dr_prediction_z1 av1_highbd_dr_prediction_z1_c ++ ++void av1_highbd_dr_prediction_z2_c(uint16_t* dst, ++ ptrdiff_t stride, ++ int bw, ++ int bh, ++ const uint16_t* above, ++ const uint16_t* left, ++ int upsample_above, ++ int upsample_left, ++ int dx, ++ int dy, ++ int bd); ++#define av1_highbd_dr_prediction_z2 av1_highbd_dr_prediction_z2_c ++ ++void av1_highbd_dr_prediction_z3_c(uint16_t* dst, ++ ptrdiff_t stride, ++ int bw, ++ int bh, ++ const uint16_t* above, ++ const uint16_t* left, ++ int upsample_left, ++ int dx, ++ int dy, ++ int bd); ++#define av1_highbd_dr_prediction_z3 av1_highbd_dr_prediction_z3_c ++ ++void av1_highbd_inv_txfm_add_c(const tran_low_t* dqcoeff, ++ uint8_t* dst, ++ int stride, ++ const TxfmParam* txfm_param); ++#define av1_highbd_inv_txfm_add av1_highbd_inv_txfm_add_c ++ ++void av1_highbd_inv_txfm_add_16x4_c(const tran_low_t* dqcoeff, ++ uint8_t* dst, ++ int stride, ++ const TxfmParam* txfm_param); ++#define av1_highbd_inv_txfm_add_16x4 av1_highbd_inv_txfm_add_16x4_c ++ ++void av1_highbd_inv_txfm_add_4x16_c(const tran_low_t* dqcoeff, ++ uint8_t* dst, ++ int stride, ++ const TxfmParam* txfm_param); ++#define av1_highbd_inv_txfm_add_4x16 av1_highbd_inv_txfm_add_4x16_c ++ ++void av1_highbd_inv_txfm_add_4x4_c(const tran_low_t* dqcoeff, ++ uint8_t* dst, ++ int stride, ++ const TxfmParam* txfm_param); ++#define av1_highbd_inv_txfm_add_4x4 av1_highbd_inv_txfm_add_4x4_c ++ ++void av1_highbd_inv_txfm_add_4x8_c(const tran_low_t* dqcoeff, ++ uint8_t* dst, ++ int stride, ++ const TxfmParam* txfm_param); ++#define av1_highbd_inv_txfm_add_4x8 av1_highbd_inv_txfm_add_4x8_c ++ ++void av1_highbd_inv_txfm_add_8x4_c(const tran_low_t* dqcoeff, ++ uint8_t* dst, ++ int stride, ++ const TxfmParam* txfm_param); ++#define av1_highbd_inv_txfm_add_8x4 av1_highbd_inv_txfm_add_8x4_c ++ ++void av1_highbd_inv_txfm_add_8x8_c(const tran_low_t* dqcoeff, ++ uint8_t* dst, ++ int stride, ++ const TxfmParam* txfm_param); ++#define av1_highbd_inv_txfm_add_8x8 av1_highbd_inv_txfm_add_8x8_c ++ ++void av1_highbd_iwht4x4_16_add_c(const tran_low_t* input, ++ uint8_t* dest, ++ int dest_stride, ++ int bd); ++#define av1_highbd_iwht4x4_16_add av1_highbd_iwht4x4_16_add_c ++ ++void av1_highbd_iwht4x4_1_add_c(const tran_low_t* input, ++ uint8_t* dest, ++ int dest_stride, ++ int bd); ++#define av1_highbd_iwht4x4_1_add av1_highbd_iwht4x4_1_add_c ++ ++void av1_highbd_warp_affine_c(const int32_t* mat, ++ const uint16_t* ref, ++ int width, ++ int height, ++ int stride, ++ uint16_t* pred, ++ int p_col, ++ int p_row, ++ int p_width, ++ int p_height, ++ int p_stride, ++ int subsampling_x, ++ int subsampling_y, ++ int bd, ++ ConvolveParams* conv_params, ++ int16_t alpha, ++ int16_t beta, ++ int16_t gamma, ++ int16_t delta); ++#define av1_highbd_warp_affine av1_highbd_warp_affine_c ++ ++void av1_highbd_wiener_convolve_add_src_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ const ConvolveParams* conv_params, ++ int bps); ++#define av1_highbd_wiener_convolve_add_src av1_highbd_wiener_convolve_add_src_c ++ ++void av1_inv_txfm2d_add_16x16_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_16x16 av1_inv_txfm2d_add_16x16_c ++ ++void av1_inv_txfm2d_add_16x32_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_16x32 av1_inv_txfm2d_add_16x32_c ++ ++void av1_inv_txfm2d_add_16x4_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_16x4 av1_inv_txfm2d_add_16x4_c ++ ++void av1_inv_txfm2d_add_16x64_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_16x64 av1_inv_txfm2d_add_16x64_c ++ ++void av1_inv_txfm2d_add_16x8_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_16x8 av1_inv_txfm2d_add_16x8_c ++ ++void av1_inv_txfm2d_add_32x16_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_32x16 av1_inv_txfm2d_add_32x16_c ++ ++void av1_inv_txfm2d_add_32x32_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_32x32 av1_inv_txfm2d_add_32x32_c ++ ++void av1_inv_txfm2d_add_32x64_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_32x64 av1_inv_txfm2d_add_32x64_c ++ ++void av1_inv_txfm2d_add_32x8_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_32x8 av1_inv_txfm2d_add_32x8_c ++ ++void av1_inv_txfm2d_add_4x16_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_4x16 av1_inv_txfm2d_add_4x16_c ++ ++void av1_inv_txfm2d_add_4x4_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_4x4 av1_inv_txfm2d_add_4x4_c ++ ++void av1_inv_txfm2d_add_4x8_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_4x8 av1_inv_txfm2d_add_4x8_c ++ ++void av1_inv_txfm2d_add_64x16_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_64x16 av1_inv_txfm2d_add_64x16_c ++ ++void av1_inv_txfm2d_add_64x32_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_64x32 av1_inv_txfm2d_add_64x32_c ++ ++void av1_inv_txfm2d_add_64x64_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_64x64 av1_inv_txfm2d_add_64x64_c ++ ++void av1_inv_txfm2d_add_8x16_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_8x16 av1_inv_txfm2d_add_8x16_c ++ ++void av1_inv_txfm2d_add_8x32_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_8x32 av1_inv_txfm2d_add_8x32_c ++ ++void av1_inv_txfm2d_add_8x4_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_8x4 av1_inv_txfm2d_add_8x4_c ++ ++void av1_inv_txfm2d_add_8x8_c(const int32_t* input, ++ uint16_t* output, ++ int stride, ++ TX_TYPE tx_type, ++ int bd); ++#define av1_inv_txfm2d_add_8x8 av1_inv_txfm2d_add_8x8_c ++ ++void av1_inv_txfm_add_c(const tran_low_t* dqcoeff, ++ uint8_t* dst, ++ int stride, ++ const TxfmParam* txfm_param); ++#define av1_inv_txfm_add av1_inv_txfm_add_c ++ ++void av1_round_shift_array_c(int32_t* arr, int size, int bit); ++#define av1_round_shift_array av1_round_shift_array_c ++ ++int av1_selfguided_restoration_c(const uint8_t* dgd8, ++ int width, ++ int height, ++ int dgd_stride, ++ int32_t* flt0, ++ int32_t* flt1, ++ int flt_stride, ++ int sgr_params_idx, ++ int bit_depth, ++ int highbd); ++#define av1_selfguided_restoration av1_selfguided_restoration_c ++ ++void av1_upsample_intra_edge_c(uint8_t* p, int sz); ++#define av1_upsample_intra_edge av1_upsample_intra_edge_c ++ ++void av1_upsample_intra_edge_high_c(uint16_t* p, int sz, int bd); ++#define av1_upsample_intra_edge_high av1_upsample_intra_edge_high_c ++ ++void av1_warp_affine_c(const int32_t* mat, ++ const uint8_t* ref, ++ int width, ++ int height, ++ int stride, ++ uint8_t* pred, ++ int p_col, ++ int p_row, ++ int p_width, ++ int p_height, ++ int p_stride, ++ int subsampling_x, ++ int subsampling_y, ++ ConvolveParams* conv_params, ++ int16_t alpha, ++ int16_t beta, ++ int16_t gamma, ++ int16_t delta); ++#define av1_warp_affine av1_warp_affine_c ++ ++void av1_wiener_convolve_add_src_c(const uint8_t* src, ++ ptrdiff_t src_stride, ++ uint8_t* dst, ++ ptrdiff_t dst_stride, ++ const int16_t* filter_x, ++ int x_step_q4, ++ const int16_t* filter_y, ++ int y_step_q4, ++ int w, ++ int h, ++ const ConvolveParams* conv_params); ++#define av1_wiener_convolve_add_src av1_wiener_convolve_add_src_c ++ ++void cdef_filter_block_c(uint8_t* dst8, ++ uint16_t* dst16, ++ int dstride, ++ const uint16_t* in, ++ int pri_strength, ++ int sec_strength, ++ int dir, ++ int pri_damping, ++ int sec_damping, ++ int bsize, ++ int coeff_shift); ++#define cdef_filter_block cdef_filter_block_c ++ ++int cdef_find_dir_c(const uint16_t* img, ++ int stride, ++ int32_t* var, ++ int coeff_shift); ++#define cdef_find_dir cdef_find_dir_c ++ ++cfl_subsample_hbd_fn cfl_get_luma_subsampling_420_hbd_c(TX_SIZE tx_size); ++#define cfl_get_luma_subsampling_420_hbd cfl_get_luma_subsampling_420_hbd_c ++ ++cfl_subsample_lbd_fn cfl_get_luma_subsampling_420_lbd_c(TX_SIZE tx_size); ++#define cfl_get_luma_subsampling_420_lbd cfl_get_luma_subsampling_420_lbd_c ++ ++cfl_subsample_hbd_fn cfl_get_luma_subsampling_422_hbd_c(TX_SIZE tx_size); ++#define cfl_get_luma_subsampling_422_hbd cfl_get_luma_subsampling_422_hbd_c ++ ++cfl_subsample_lbd_fn cfl_get_luma_subsampling_422_lbd_c(TX_SIZE tx_size); ++#define cfl_get_luma_subsampling_422_lbd cfl_get_luma_subsampling_422_lbd_c ++ ++cfl_subsample_hbd_fn cfl_get_luma_subsampling_444_hbd_c(TX_SIZE tx_size); ++#define cfl_get_luma_subsampling_444_hbd cfl_get_luma_subsampling_444_hbd_c ++ ++cfl_subsample_lbd_fn cfl_get_luma_subsampling_444_lbd_c(TX_SIZE tx_size); ++#define cfl_get_luma_subsampling_444_lbd cfl_get_luma_subsampling_444_lbd_c ++ ++void copy_rect8_16bit_to_16bit_c(uint16_t* dst, ++ int dstride, ++ const uint16_t* src, ++ int sstride, ++ int v, ++ int h); ++#define copy_rect8_16bit_to_16bit copy_rect8_16bit_to_16bit_c ++ ++void copy_rect8_8bit_to_16bit_c(uint16_t* dst, ++ int dstride, ++ const uint8_t* src, ++ int sstride, ++ int v, ++ int h); ++#define copy_rect8_8bit_to_16bit copy_rect8_8bit_to_16bit_c ++ ++cfl_predict_hbd_fn get_predict_hbd_fn_c(TX_SIZE tx_size); ++#define get_predict_hbd_fn get_predict_hbd_fn_c ++ ++cfl_predict_lbd_fn get_predict_lbd_fn_c(TX_SIZE tx_size); ++#define get_predict_lbd_fn get_predict_lbd_fn_c ++ ++cfl_subtract_average_fn get_subtract_average_fn_c(TX_SIZE tx_size); ++cfl_subtract_average_fn get_subtract_average_fn_vsx(TX_SIZE tx_size); ++#define get_subtract_average_fn get_subtract_average_fn_vsx ++ ++void av1_rtcd(void); ++ ++#include "config/aom_config.h" ++ ++#ifdef RTCD_C ++#include "aom_ports/ppc.h" ++static void setup_rtcd_internal(void) { ++ int flags = ppc_simd_caps(); ++ ++ (void)flags; ++} ++#endif ++ ++#ifdef __cplusplus ++} // extern "C" ++#endif ++ ++#endif +-- +2.21.1 + + +From c25ceaa3c742b5bf8ff32211671cc815fa289fc6 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 13:44:49 +0100 +Subject: [PATCH 07/13] update third_party/breakpad for ppc64 + +--- + .../dump_writer_common/raw_context_cpu.h | 2 + + .../linux/dump_writer_common/thread_info.cc | 56 ++++++++++++++++++- + .../linux/dump_writer_common/thread_info.h | 9 +++ + .../dump_writer_common/ucontext_reader.cc | 42 ++++++++++++++ + .../dump_writer_common/ucontext_reader.h | 3 + + .../client/linux/handler/exception_handler.cc | 22 +++++++- + .../client/linux/handler/exception_handler.h | 6 +- + .../handler/exception_handler_unittest.cc | 8 ++- + .../microdump_writer/microdump_writer.cc | 14 ++++- + .../microdump_writer_unittest.cc | 15 ++++- + .../minidump_writer/linux_core_dumper.cc | 8 ++- + .../linux/minidump_writer/linux_dumper.cc | 4 +- + .../linux/minidump_writer/linux_dumper.h | 3 +- + .../linux_dumper_unittest_helper.cc | 2 + + .../minidump_writer/linux_ptrace_dumper.cc | 19 +++++-- + .../linux_ptrace_dumper_unittest.cc | 5 ++ + .../linux/minidump_writer/minidump_writer.cc | 18 ++++-- + .../linux/minidump_writer/minidump_writer.h | 2 + + .../minidump_writer_unittest.cc | 3 + + .../src/common/linux/memory_mapped_file.cc | 3 +- + .../linux/memory_mapped_file_unittest.cc | 7 ++- + .../src/common/memory_allocator_unittest.cc | 3 +- + .../src/processor/exploitability_linux.cc | 2 + + .../src/processor/exploitability_unittest.cc | 15 +++-- + .../tools/linux/md2core/minidump-2-core.cc | 45 +++++++++++++++ + 25 files changed, 281 insertions(+), 35 deletions(-) + +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/raw_context_cpu.h b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/raw_context_cpu.h +index 07d9171a0a6..9aed4cb369b 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/raw_context_cpu.h ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/raw_context_cpu.h +@@ -44,6 +44,8 @@ typedef MDRawContextARM RawContextCPU; + typedef MDRawContextARM64_Old RawContextCPU; + #elif defined(__mips__) + typedef MDRawContextMIPS RawContextCPU; ++#elif defined(__powerpc64__) ++typedef MDRawContextPPC64 RawContextCPU; + #else + #error "This code has not been ported to your platform yet." + #endif +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/thread_info.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/thread_info.cc +index aae1dc13b25..03afec7a58d 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/thread_info.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/thread_info.cc +@@ -270,7 +270,42 @@ void ThreadInfo::FillCPUContext(RawContextCPU* out) const { + out->float_save.fir = mcontext.fpc_eir; + #endif + } +-#endif // __mips__ ++ ++#elif defined(__powerpc64__) ++ ++uintptr_t ThreadInfo::GetInstructionPointer() const { ++ return mcontext.gp_regs[PT_NIP]; ++} ++ ++void ThreadInfo::FillCPUContext(RawContextCPU* out) const { ++ out->context_flags = MD_CONTEXT_PPC64_FULL; ++ for (int i = 0; i < MD_CONTEXT_PPC64_GPR_COUNT; i++) ++ out->gpr[i] = mcontext.gp_regs[i]; ++ ++ out->lr = mcontext.gp_regs[PT_LNK]; ++ out->srr0 = mcontext.gp_regs[PT_NIP]; ++ out->srr1 = mcontext.gp_regs[PT_MSR]; ++ out->cr = mcontext.gp_regs[PT_CCR]; ++ out->xer = mcontext.gp_regs[PT_XER]; ++ out->ctr = mcontext.gp_regs[PT_CTR]; ++ ++ for (int i = 0; i < MD_FLOATINGSAVEAREA_PPC_FPR_COUNT; i++) ++ out->float_save.fpregs[i] = mcontext.fp_regs[i]; ++ ++ out->float_save.fpscr = mcontext.fp_regs[NFPREG-1]; ++ ++ for (int i = 0; i < MD_VECTORSAVEAREA_PPC_VR_COUNT; i++) ++ out->vector_save.save_vr[i] = \ ++ {(((uint64_t)vregs.vrregs[i][0]) << 32) ++ | vregs.vrregs[i][1], ++ (((uint64_t)vregs.vrregs[i][2]) << 32) ++ | vregs.vrregs[i][3]}; ++ ++ out->vrsave = vregs.vrsave; ++ out->vector_save.save_vscr = {0, vregs.vscr.vscr_word}; ++ out->vector_save.save_vrvalid = 0xFFFFFFFF; ++} ++#endif // __powerpc64__ + + void ThreadInfo::GetGeneralPurposeRegisters(void** gp_regs, size_t* size) { + assert(gp_regs || size); +@@ -279,6 +314,11 @@ void ThreadInfo::GetGeneralPurposeRegisters(void** gp_regs, size_t* size) { + *gp_regs = mcontext.gregs; + if (size) + *size = sizeof(mcontext.gregs); ++#elif defined(__powerpc64__) ++ if (gp_regs) ++ *gp_regs = mcontext.gp_regs; ++ if (size) ++ *size = sizeof(mcontext.gp_regs); + #else + if (gp_regs) + *gp_regs = ®s; +@@ -294,6 +334,11 @@ void ThreadInfo::GetFloatingPointRegisters(void** fp_regs, size_t* size) { + *fp_regs = &mcontext.fpregs; + if (size) + *size = sizeof(mcontext.fpregs); ++#elif defined(__powerpc64__) ++ if (fp_regs) ++ *fp_regs = &mcontext.fp_regs; ++ if (size) ++ *size = sizeof(mcontext.fp_regs); + #else + if (fp_regs) + *fp_regs = &fpregs; +@@ -302,4 +347,13 @@ void ThreadInfo::GetFloatingPointRegisters(void** fp_regs, size_t* size) { + #endif + } + ++#if defined(__powerpc64__) ++void ThreadInfo::GetVectorRegisters(void** v_regs, size_t* size) { ++ if (v_regs) ++ *v_regs = &vregs; ++ if (size) ++ *size = sizeof(vregs); ++} ++#endif ++ + } // namespace google_breakpad +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/thread_info.h b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/thread_info.h +index fb216fa6d71..fb669126f7f 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/thread_info.h ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/thread_info.h +@@ -68,6 +68,10 @@ struct ThreadInfo { + // Use the structures defined in + struct user_regs_struct regs; + struct user_fpsimd_struct fpregs; ++#elif defined(__powerpc64__) ++ // Use the structures defined in . ++ mcontext_t mcontext; ++ struct _libc_vrstate vregs; + #elif defined(__mips__) + // Use the structure defined in . + mcontext_t mcontext; +@@ -84,6 +88,11 @@ struct ThreadInfo { + + // Returns the pointer and size of float point register area. + void GetFloatingPointRegisters(void** fp_regs, size_t* size); ++ ++#if defined(__powerpc64__) ++ // Returns the pointer and size of the vector register area. (PPC64 only) ++ void GetVectorRegisters(void** v_regs, size_t* size); ++#endif + }; + + } // namespace google_breakpad +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/ucontext_reader.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/ucontext_reader.cc +index 6ee6cc1e4cd..477352e37e2 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/ucontext_reader.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/ucontext_reader.cc +@@ -254,6 +254,48 @@ void UContextReader::FillCPUContext(RawContextCPU *out, const ucontext_t *uc) { + out->float_save.fir = uc->uc_mcontext.fpc_eir; // Unused. + #endif + } ++ ++#elif defined(__powerpc64__) ++ ++uintptr_t UContextReader::GetStackPointer(const ucontext_t* uc) { ++ return uc->uc_mcontext.gp_regs[MD_CONTEXT_PPC64_REG_SP]; ++} ++ ++uintptr_t UContextReader::GetInstructionPointer(const ucontext_t* uc) { ++ return uc->uc_mcontext.gp_regs[PT_NIP]; ++} ++ ++void UContextReader::FillCPUContext(RawContextCPU* out, const ucontext_t* uc, ++ const struct _libc_vrstate* vregs) { ++ out->context_flags = MD_CONTEXT_PPC64_FULL; ++ ++ for (int i = 0; i < MD_CONTEXT_PPC64_GPR_COUNT; i++) ++ out->gpr[i] = uc->uc_mcontext.gp_regs[i]; ++ ++ out->lr = uc->uc_mcontext.gp_regs[PT_LNK]; ++ out->srr0 = uc->uc_mcontext.gp_regs[PT_NIP]; ++ out->srr1 = uc->uc_mcontext.gp_regs[PT_MSR]; ++ out->cr = uc->uc_mcontext.gp_regs[PT_CCR]; ++ out->xer = uc->uc_mcontext.gp_regs[PT_XER]; ++ out->ctr = uc->uc_mcontext.gp_regs[PT_CTR]; ++ ++ for (int i = 0; i < MD_FLOATINGSAVEAREA_PPC_FPR_COUNT; i++) ++ out->float_save.fpregs[i] = uc->uc_mcontext.fp_regs[i]; ++ ++ out->float_save.fpscr = uc->uc_mcontext.fp_regs[NFPREG-1]; ++ ++ for (int i = 0; i < MD_VECTORSAVEAREA_PPC_VR_COUNT; i++) ++ out->vector_save.save_vr[i] = ++ {(((uint64_t)vregs->vrregs[i][0]) << 32) ++ | vregs->vrregs[i][1], ++ (((uint64_t)vregs->vrregs[i][2]) << 32) ++ | vregs->vrregs[i][3]}; ++ ++ out->vrsave = vregs->vrsave; ++ out->vector_save.save_vscr = {0, vregs->vscr.vscr_word}; ++ out->vector_save.save_vrvalid = 0xFFFFFFFF; ++} ++ + #endif + + } // namespace google_breakpad +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/ucontext_reader.h b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/ucontext_reader.h +index f830618f240..6248818e784 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/ucontext_reader.h ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/dump_writer_common/ucontext_reader.h +@@ -54,6 +54,9 @@ struct UContextReader { + #elif defined(__aarch64__) + static void FillCPUContext(RawContextCPU *out, const ucontext_t *uc, + const struct fpsimd_context* fpregs); ++#elif defined(__powerpc64__) ++ static void FillCPUContext(RawContextCPU *out, const ucontext_t *uc, ++ const struct _libc_vrstate* vregs); + #else + static void FillCPUContext(RawContextCPU *out, const ucontext_t *uc); + #endif +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler.cc +index 0d7cd9cfce4..63b8262db81 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler.cc +@@ -467,9 +467,16 @@ bool ExceptionHandler::HandleSignal(int /*sig*/, siginfo_t* info, void* uc) { + memcpy(&g_crash_context_.float_state, fp_ptr, + sizeof(g_crash_context_.float_state)); + } ++#elif defined(__powerpc64__) ++ // On PPC64, we must copy VR state ++ ucontext_t* uc_ptr = (ucontext_t*)uc; ++ if (uc_ptr->uc_mcontext.v_regs) { ++ memcpy(&g_crash_context_.vector_state, uc_ptr->uc_mcontext.v_regs, ++ sizeof(g_crash_context_.vector_state)); ++ } + #elif !defined(__ARM_EABI__) && !defined(__mips__) + // FP state is not part of user ABI on ARM Linux. +- // In case of MIPS Linux FP state is already part of ucontext_t ++ // In case of MIPS, Linux FP state is already part of ucontext_t + // and 'float_state' is not a member of CrashContext. + ucontext_t* uc_ptr = (ucontext_t*)uc; + if (uc_ptr->uc_mcontext.fpregs) { +@@ -707,11 +714,19 @@ bool ExceptionHandler::WriteMinidump() { + } + #endif + +-#if !defined(__ARM_EABI__) && !defined(__aarch64__) && !defined(__mips__) ++#if !defined(__ARM_EABI__) && !defined(__aarch64__) && !defined(__mips__) \ ++ && !defined(__powerpc64__) + // FPU state is not part of ARM EABI ucontext_t. + memcpy(&context.float_state, context.context.uc_mcontext.fpregs, + sizeof(context.float_state)); + #endif ++ ++#if defined(__powerpc64__) ++ // Vector registers must be copied on PPC64 ++ memcpy(&context.vector_state, context.context.uc_mcontext.v_regs, ++ sizeof(context.vector_state)); ++#endif ++ + context.tid = sys_gettid(); + + // Add an exception stream to the minidump for better reporting. +@@ -732,6 +747,9 @@ bool ExceptionHandler::WriteMinidump() { + #elif defined(__mips__) + context.siginfo.si_addr = + reinterpret_cast(context.context.uc_mcontext.pc); ++#elif defined(__powerpc64__) ++ context.siginfo.si_addr = ++ reinterpret_cast(context.context.uc_mcontext.gp_regs[PT_NIP]); + #else + #error "This code has not been ported to your platform yet." + #endif +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler.h b/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler.h +index 1ddeac883b8..ddcb808be27 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler.h ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler.h +@@ -192,7 +192,11 @@ class ExceptionHandler { + siginfo_t siginfo; + pid_t tid; // the crashing thread. + ucontext_t context; +-#if !defined(__ARM_EABI__) && !defined(__mips__) ++#if defined(__powerpc64__) ++ // PPC64's FP state is a part of ucontext_t like MIPS but the vector ++ // state is not, so a struct is needed. ++ vstate_t vector_state; ++#elif !defined(__ARM_EABI__) && !defined(__mips__) + // #ifdef this out because FP state is not part of user ABI for Linux ARM. + // In case of MIPS Linux FP state is already part of ucontext_t so + // 'float_state' is not required. +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler_unittest.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler_unittest.cc +index 2e4eb09a0a4..5a0e148f341 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler_unittest.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/handler/exception_handler_unittest.cc +@@ -307,7 +307,7 @@ TEST(ExceptionHandlerTest, ParallelChildCrashesDontHang) { + } + + // Wait a while until the child should have crashed. +- usleep(1000000); ++ usleep(2000000); + // Kill the child if it is still running. + kill(child, SIGKILL); + +@@ -576,6 +576,8 @@ const unsigned char kIllegalInstruction[] = { + #if defined(__mips__) + // mfc2 zero,Impl - usually illegal in userspace. + 0x48, 0x00, 0x00, 0x48 ++#elif defined(__powerpc64__) ++ 0x01, 0x01, 0x01, 0x01 // Crashes on a tested POWER9 cpu + #else + // This crashes with SIGILL on x86/x86-64/arm. + 0xff, 0xff, 0xff, 0xff +@@ -771,10 +773,10 @@ TEST(ExceptionHandlerTest, InstructionPointerMemoryMaxBound) { + + // These are defined here so the parent can use them to check the + // data from the minidump afterwards. +- // Use 4k here because the OS will hand out a single page even ++ // Use the page size here because the OS will hand out a single page even + // if a smaller size is requested, and this test wants to + // test the upper bound of the memory range. +- const uint32_t kMemorySize = 4096; // bytes ++ const uint32_t kMemorySize = getpagesize(); // bytes + const int kOffset = kMemorySize - sizeof(kIllegalInstruction); + + const pid_t child = fork(); +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/microdump_writer/microdump_writer.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/microdump_writer/microdump_writer.cc +index fa3c1713a56..6ce709e2f00 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/microdump_writer/microdump_writer.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/microdump_writer/microdump_writer.cc +@@ -138,7 +138,9 @@ class MicrodumpWriter { + const MicrodumpExtraInfo& microdump_extra_info, + LinuxDumper* dumper) + : ucontext_(context ? &context->context : NULL), +-#if !defined(__ARM_EABI__) && !defined(__mips__) ++#if defined(__powerpc64__) ++ vector_state_(context ? &context->vector_state : NULL), ++#elif !defined(__ARM_EABI__) && !defined(__mips__) + float_state_(context ? &context->float_state : NULL), + #endif + dumper_(dumper), +@@ -337,6 +339,8 @@ class MicrodumpWriter { + # else + # error "This mips ABI is currently not supported (n32)" + #endif ++#elif defined(__powerpc64__) ++ const char kArch[] = "ppc64"; + #else + #error "This code has not been ported to your platform yet" + #endif +@@ -409,7 +413,9 @@ class MicrodumpWriter { + void DumpCPUState() { + RawContextCPU cpu; + my_memset(&cpu, 0, sizeof(RawContextCPU)); +-#if !defined(__ARM_EABI__) && !defined(__mips__) ++#if defined(__powerpc64__) ++ UContextReader::FillCPUContext(&cpu, ucontext_, vector_state_); ++#elif !defined(__ARM_EABI__) && !defined(__mips__) + UContextReader::FillCPUContext(&cpu, ucontext_, float_state_); + #else + UContextReader::FillCPUContext(&cpu, ucontext_); +@@ -605,7 +611,9 @@ class MicrodumpWriter { + void* Alloc(unsigned bytes) { return dumper_->allocator()->Alloc(bytes); } + + const ucontext_t* const ucontext_; +-#if !defined(__ARM_EABI__) && !defined(__mips__) ++#if defined(__powerpc64__) ++ const google_breakpad::vstate_t* const vector_state_; ++#elif !defined(__ARM_EABI__) && !defined(__mips__) + const google_breakpad::fpstate_t* const float_state_; + #endif + LinuxDumper* dumper_; +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/microdump_writer/microdump_writer_unittest.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/microdump_writer/microdump_writer_unittest.cc +index c2fea0225ed..8c62c524a20 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/microdump_writer/microdump_writer_unittest.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/microdump_writer/microdump_writer_unittest.cc +@@ -278,10 +278,19 @@ TEST(MicrodumpWriterTest, BasicWithMappings) { + CrashAndGetMicrodump(mappings, MicrodumpExtraInfo(), &buf); + ASSERT_TRUE(ContainsMicrodump(buf)); + ++ int page_size = getpagesize(); + #ifdef __LP64__ +- ASSERT_NE(std::string::npos, +- buf.find("M 0000000000001000 000000000000002A 0000000000001000 " +- "33221100554477668899AABBCCDDEEFF0 libfoo.so")); ++ // This test is only available for the following page sizes ++ ASSERT_TRUE((page_size == 4096) || (page_size == 65536)); ++ if (page_size == 4096) { ++ ASSERT_NE(std::string::npos, ++ buf.find("M 0000000000001000 000000000000002A 0000000000001000 " ++ "33221100554477668899AABBCCDDEEFF0 libfoo.so")); ++ } else { ++ ASSERT_NE(std::string::npos, ++ buf.find("M 0000000000010000 000000000000002A 0000000000010000 " ++ "33221100554477668899AABBCCDDEEFF0 libfoo.so")); ++ } + #else + ASSERT_NE(std::string::npos, + buf.find("M 00001000 0000002A 00001000 " +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_core_dumper.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_core_dumper.cc +index 9bf2d2eff11..182624963fa 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_core_dumper.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_core_dumper.cc +@@ -111,6 +111,9 @@ bool LinuxCoreDumper::GetThreadInfoByIndex(size_t index, ThreadInfo* info) { + #elif defined(__mips__) + stack_pointer = + reinterpret_cast(info->mcontext.gregs[MD_CONTEXT_MIPS_REG_SP]); ++#elif defined(__powerpc64__) ++ stack_pointer = ++ reinterpret_cast(info->mcontext.gp_regs[MD_CONTEXT_PPC64_REG_SP]); + #else + #error "This code hasn't been ported to your platform yet." + #endif +@@ -195,7 +198,10 @@ bool LinuxCoreDumper::EnumerateThreads() { + memset(&info, 0, sizeof(ThreadInfo)); + info.tgid = status->pr_pgrp; + info.ppid = status->pr_ppid; +-#if defined(__mips__) ++#if defined(__powerpc64__) ++ for (int i = 0; i < 31; i++) ++ info.mcontext.gp_regs[i] = status->pr_reg[i]; ++#elif defined(__mips__) + #if defined(__ANDROID__) + for (int i = EF_R0; i <= EF_R31; i++) + info.mcontext.gregs[i - EF_R0] = status->pr_reg[i]; +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper.cc +index dbedecd530b..f91f7f99405 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper.cc +@@ -798,7 +798,9 @@ bool LinuxDumper::GetStackInfo(const void** stack, size_t* stack_len, + reinterpret_cast(int_stack_pointer & ~(page_size - 1)); + + // The number of bytes of stack which we try to capture. +- static const ptrdiff_t kStackToCapture = 32 * 1024; ++ // This now depends on page_size to avoid missing data ++ // on systems with larger page sizes. ++ static const ptrdiff_t kStackToCapture = 8 * page_size; + + const MappingInfo* mapping = FindMapping(stack_pointer); + if (!mapping) +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper.h b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper.h +index 76448fad863..617ac6d0861 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper.h ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper.h +@@ -60,7 +60,8 @@ namespace google_breakpad { + (defined(__mips__) && _MIPS_SIM == _ABIO32) + typedef Elf32_auxv_t elf_aux_entry; + #elif defined(__x86_64) || defined(__aarch64__) || \ +- (defined(__mips__) && _MIPS_SIM != _ABIO32) ++ (defined(__mips__) && _MIPS_SIM != _ABIO32) || \ ++ defined(__powerpc64__) + typedef Elf64_auxv_t elf_aux_entry; + #endif + +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc +index 3ad48e50155..1688c365ef1 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_dumper_unittest_helper.cc +@@ -51,6 +51,8 @@ + #define TID_PTR_REGISTER "rcx" + #elif defined(__mips__) + #define TID_PTR_REGISTER "$1" ++#elif defined(__powerpc64__) ++#define TID_PTR_REGISTER "r8" + #else + #error This test has not been ported to this platform. + #endif +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper.cc +index e3ddb81a659..fa28575ef54 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper.cc +@@ -149,19 +149,27 @@ bool LinuxPtraceDumper::CopyFromProcess(void* dest, pid_t child, + return true; + } + +-bool LinuxPtraceDumper::ReadRegisterSet(ThreadInfo* info, pid_t tid) +-{ ++bool LinuxPtraceDumper::ReadRegisterSet(ThreadInfo* info, pid_t tid) { + #ifdef PTRACE_GETREGSET + struct iovec io; + info->GetGeneralPurposeRegisters(&io.iov_base, &io.iov_len); +- if (sys_ptrace(PTRACE_GETREGSET, tid, (void*)NT_PRSTATUS, (void*)&io) == -1) { ++ if (ptrace(PTRACE_GETREGSET, tid, (void*)NT_PRSTATUS, (void*)&io) == -1) { + return false; + } + + info->GetFloatingPointRegisters(&io.iov_base, &io.iov_len); +- if (sys_ptrace(PTRACE_GETREGSET, tid, (void*)NT_FPREGSET, (void*)&io) == -1) { ++ if (ptrace(PTRACE_GETREGSET, tid, (void*)NT_FPREGSET, (void*)&io) == -1) { + return false; + } ++ ++#if defined(__powerpc64__) ++ // Grab the vector registers on PPC64 too ++ info->GetVectorRegisters(&io.iov_base, &io.iov_len); ++ if (ptrace(PTRACE_GETREGSET, tid, (void*)NT_PPC_VMX, (void*)&io) == -1) { ++ return false; ++ } ++#endif // defined(__powerpc64__) ++ + return true; + #else + return false; +@@ -298,6 +306,9 @@ bool LinuxPtraceDumper::GetThreadInfoByIndex(size_t index, ThreadInfo* info) { + #elif defined(__mips__) + stack_pointer = + reinterpret_cast(info->mcontext.gregs[MD_CONTEXT_MIPS_REG_SP]); ++#elif defined(__powerpc64__) ++ stack_pointer = ++ reinterpret_cast(info->mcontext.gp_regs[MD_CONTEXT_PPC64_REG_SP]); + #else + #error "This code hasn't been ported to your platform yet." + #endif +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc +index a4a0fd9b63e..52c150704e8 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc +@@ -457,6 +457,9 @@ TEST(LinuxPtraceDumperTest, VerifyStackReadWithMultipleThreads) { + #elif defined(__mips__) + pid_t* process_tid_location = + reinterpret_cast(one_thread.mcontext.gregs[1]); ++#elif defined(__powerpc64__) ++ pid_t* process_tid_location = ++ reinterpret_cast(one_thread.mcontext.gp_regs[8]); + #else + #error This test has not been ported to this platform. + #endif +@@ -553,6 +556,8 @@ TEST_F(LinuxPtraceDumperTest, SanitizeStackCopy) { + uintptr_t heap_addr = thread_info.regs.rcx; + #elif defined(__mips__) + uintptr_t heap_addr = thread_info.mcontext.gregs[1]; ++#elif defined(__powerpc64__) ++ uintptr_t heap_addr = thread_info.mcontext.gp_regs[8]; + #else + #error This test has not been ported to this platform. + #endif +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.cc +index 31e7bd62adb..ad36856d676 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.cc +@@ -136,7 +136,9 @@ class MinidumpWriter { + : fd_(minidump_fd), + path_(minidump_path), + ucontext_(context ? &context->context : NULL), +-#if !defined(__ARM_EABI__) && !defined(__mips__) ++#if defined(__powerpc64__) ++ vector_state_(context ? &context->vector_state : NULL), ++#elif !defined(__ARM_EABI__) && !defined(__mips__) + float_state_(context ? &context->float_state : NULL), + #endif + dumper_(dumper), +@@ -468,7 +470,9 @@ class MinidumpWriter { + if (!cpu.Allocate()) + return false; + my_memset(cpu.get(), 0, sizeof(RawContextCPU)); +-#if !defined(__ARM_EABI__) && !defined(__mips__) ++#if defined(__powerpc64__) ++ UContextReader::FillCPUContext(cpu.get(), ucontext_, vector_state_); ++#elif !defined(__ARM_EABI__) && !defined(__mips__) + UContextReader::FillCPUContext(cpu.get(), ucontext_, float_state_); + #else + UContextReader::FillCPUContext(cpu.get(), ucontext_); +@@ -891,7 +895,7 @@ class MinidumpWriter { + dirent->location.rva = 0; + } + +-#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) ++#if defined(__i386__) || defined(__x86_64__) || defined(__mips__) || defined(__powerpc64__) + bool WriteCPUInformation(MDRawSystemInfo* sys_info) { + char vendor_id[sizeof(sys_info->cpu.x86_cpu_info.vendor_id) + 1] = {0}; + static const char vendor_id_name[] = "vendor_id"; +@@ -911,7 +915,9 @@ class MinidumpWriter { + + // processor_architecture should always be set, do this first + sys_info->processor_architecture = +-#if defined(__mips__) ++#if defined(__powerpc64__) ++ MD_CPU_ARCHITECTURE_PPC64; ++#elif defined(__mips__) + # if _MIPS_SIM == _ABIO32 + MD_CPU_ARCHITECTURE_MIPS; + # elif _MIPS_SIM == _ABI64 +@@ -1327,7 +1333,9 @@ class MinidumpWriter { + const char* path_; // Path to the file where the minidum should be written. + + const ucontext_t* const ucontext_; // also from the signal handler +-#if !defined(__ARM_EABI__) && !defined(__mips__) ++#if defined(__powerpc64__) ++ const google_breakpad::vstate_t* const vector_state_; ++#elif !defined(__ARM_EABI__) && !defined(__mips__) + const google_breakpad::fpstate_t* const float_state_; // ditto + #endif + LinuxDumper* dumper_; +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.h b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.h +index d1dc331215a..63d80592280 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.h ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer.h +@@ -47,6 +47,8 @@ class ExceptionHandler; + + #if defined(__aarch64__) + typedef struct fpsimd_context fpstate_t; ++#elif defined(__powerpc64__) ++typedef struct _libc_vrstate vstate_t; + #elif !defined(__ARM_EABI__) && !defined(__mips__) + typedef struct _libc_fpstate fpstate_t; + #endif +diff --git a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer_unittest.cc b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer_unittest.cc +index 583ddda86de..5e3deccfd7d 100644 +--- a/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer_unittest.cc ++++ b/chromium/third_party/breakpad/breakpad/src/client/linux/minidump_writer/minidump_writer_unittest.cc +@@ -710,6 +710,9 @@ TEST(MinidumpWriterTest, InvalidStackPointer) { + #elif defined(__mips__) + context.context.uc_mcontext.gregs[MD_CONTEXT_MIPS_REG_SP] = + invalid_stack_pointer; ++#elif defined(__powerpc64__) ++ context.context.uc_mcontext.gp_regs[MD_CONTEXT_PPC64_REG_SP] = ++ invalid_stack_pointer; + #else + # error "This code has not been ported to your platform yet." + #endif +diff --git a/chromium/third_party/breakpad/breakpad/src/common/linux/memory_mapped_file.cc b/chromium/third_party/breakpad/breakpad/src/common/linux/memory_mapped_file.cc +index 4e938269f26..f0ff15d9671 100644 +--- a/chromium/third_party/breakpad/breakpad/src/common/linux/memory_mapped_file.cc ++++ b/chromium/third_party/breakpad/breakpad/src/common/linux/memory_mapped_file.cc +@@ -65,8 +65,7 @@ bool MemoryMappedFile::Map(const char* path, size_t offset) { + } + + #if defined(__x86_64__) || defined(__aarch64__) || \ +- (defined(__mips__) && _MIPS_SIM == _ABI64) +- ++ (defined(__mips__) && _MIPS_SIM == _ABI64) || defined(__powerpc64__) + struct kernel_stat st; + if (sys_fstat(fd, &st) == -1 || st.st_size < 0) { + #else +diff --git a/chromium/third_party/breakpad/breakpad/src/common/linux/memory_mapped_file_unittest.cc b/chromium/third_party/breakpad/breakpad/src/common/linux/memory_mapped_file_unittest.cc +index fad59f40cd1..616496d672b 100644 +--- a/chromium/third_party/breakpad/breakpad/src/common/linux/memory_mapped_file_unittest.cc ++++ b/chromium/third_party/breakpad/breakpad/src/common/linux/memory_mapped_file_unittest.cc +@@ -176,9 +176,10 @@ TEST_F(MemoryMappedFileTest, RemapAfterMap) { + TEST_F(MemoryMappedFileTest, MapWithOffset) { + // Put more data in the test file this time. Offsets can only be + // done on page boundaries, so we need a two page file to test this. +- const int page_size = 4096; +- char data1[2 * page_size]; +- size_t data1_size = sizeof(data1); ++ const int page_size = getpagesize(); ++ char *data1 = static_cast(malloc(2 * page_size)); ++ EXPECT_TRUE(data1 != NULL); ++ size_t data1_size = (2 * page_size); + for (size_t i = 0; i < data1_size; ++i) { + data1[i] = i & 0x7f; + } +diff --git a/chromium/third_party/breakpad/breakpad/src/common/memory_allocator_unittest.cc b/chromium/third_party/breakpad/breakpad/src/common/memory_allocator_unittest.cc +index 43c86314c64..27325b813b1 100644 +--- a/chromium/third_party/breakpad/breakpad/src/common/memory_allocator_unittest.cc ++++ b/chromium/third_party/breakpad/breakpad/src/common/memory_allocator_unittest.cc +@@ -57,8 +57,9 @@ TEST(PageAllocatorTest, LargeObject) { + + EXPECT_EQ(0U, allocator.pages_allocated()); + uint8_t *p = reinterpret_cast(allocator.Alloc(10000)); ++ uint64_t expected_pages = 1 + ((10000 - 1) / getpagesize()); + ASSERT_FALSE(p == NULL); +- EXPECT_EQ(3U, allocator.pages_allocated()); ++ EXPECT_EQ(expected_pages, allocator.pages_allocated()); + for (unsigned i = 1; i < 10; ++i) { + uint8_t *p = reinterpret_cast(allocator.Alloc(i)); + ASSERT_FALSE(p == NULL); +diff --git a/chromium/third_party/breakpad/breakpad/src/processor/exploitability_linux.cc b/chromium/third_party/breakpad/breakpad/src/processor/exploitability_linux.cc +index ccc9f1459cc..debaed4d6ef 100644 +--- a/chromium/third_party/breakpad/breakpad/src/processor/exploitability_linux.cc ++++ b/chromium/third_party/breakpad/breakpad/src/processor/exploitability_linux.cc +@@ -202,12 +202,14 @@ bool ExploitabilityLinux::EndedOnIllegalWrite(uint64_t instruction_ptr) { + // Check architecture and set architecture variable to corresponding flag + // in objdump. + switch (context->GetContextCPU()) { ++#if defined(__i386) || defined(__x86_64) + case MD_CONTEXT_X86: + architecture = "i386"; + break; + case MD_CONTEXT_AMD64: + architecture = "i386:x86-64"; + break; ++#endif + default: + // Unsupported architecture. Note that ARM architectures are not + // supported because objdump does not support ARM. +diff --git a/chromium/third_party/breakpad/breakpad/src/processor/exploitability_unittest.cc b/chromium/third_party/breakpad/breakpad/src/processor/exploitability_unittest.cc +index 528ee5f2137..72764d6c1e0 100644 +--- a/chromium/third_party/breakpad/breakpad/src/processor/exploitability_unittest.cc ++++ b/chromium/third_party/breakpad/breakpad/src/processor/exploitability_unittest.cc +@@ -104,6 +104,8 @@ ExploitabilityFor(const string& filename) { + } + + TEST(ExploitabilityTest, TestWindowsEngine) { ++// The following tests are only executable on an x86-class linux machine. ++#if !defined(_WIN32) && (defined(__i386) || defined(__x86_64)) + ASSERT_EQ(google_breakpad::EXPLOITABILITY_HIGH, + ExploitabilityFor("ascii_read_av.dmp")); + ASSERT_EQ(google_breakpad::EXPLOITABILITY_HIGH, +@@ -136,9 +138,12 @@ TEST(ExploitabilityTest, TestWindowsEngine) { + ExploitabilityFor("read_av_clobber_write.dmp")); + ASSERT_EQ(google_breakpad::EXPLOITABILITY_LOW, + ExploitabilityFor("read_av_conditional.dmp")); ++#endif + } + + TEST(ExploitabilityTest, TestLinuxEngine) { ++// The following tests are only executable on an x86-class linux machine. ++#if defined(__i386) || defined(__x86_64) + ASSERT_EQ(google_breakpad::EXPLOITABILITY_INTERESTING, + ExploitabilityFor("linux_null_read_av.dmp")); + ASSERT_EQ(google_breakpad::EXPLOITABILITY_HIGH, +@@ -171,7 +176,8 @@ TEST(ExploitabilityTest, TestLinuxEngine) { + ExploitabilityFor("linux_executable_heap.dmp")); + ASSERT_EQ(google_breakpad::EXPLOITABILITY_HIGH, + ExploitabilityFor("linux_jmp_to_module_not_exe_region.dmp")); +-#ifndef _WIN32 ++#endif ++#if !defined(_WIN32) && (defined(__i386) || defined(__x86_64)) + ASSERT_EQ(google_breakpad::EXPLOITABILITY_HIGH, + ExploitabilityFor("linux_write_to_nonwritable_module.dmp")); + ASSERT_EQ(google_breakpad::EXPLOITABILITY_HIGH, +@@ -182,10 +188,10 @@ TEST(ExploitabilityTest, TestLinuxEngine) { + ExploitabilityFor("linux_write_to_outside_module_via_math.dmp")); + ASSERT_EQ(google_breakpad::EXPLOITABILITY_INTERESTING, + ExploitabilityFor("linux_write_to_under_4k.dmp")); +-#endif // _WIN32 ++#endif // !defined(_WIN32) && (!defined(__i386) && !defined(__x86_64)) + } + +-#ifndef _WIN32 ++#if !defined(_WIN32) && (defined(__i386) || defined(__x86_64)) + TEST(ExploitabilityLinuxUtilsTest, DisassembleBytesTest) { + ASSERT_FALSE(ExploitabilityLinuxTest::DisassembleBytes("", NULL, 5, NULL)); + uint8_t bytes[6] = {0xc7, 0x0, 0x5, 0x0, 0x0, 0x0}; +@@ -301,6 +307,7 @@ TEST(ExploitabilityLinuxUtilsTest, CalculateAddressTest) { + context, + &write_address)); + } +-#endif // _WIN32 ++#endif // !defined(_WIN32) && (defined(__i386) || defined(__x86_64)) ++ + + } // namespace +diff --git a/chromium/third_party/breakpad/breakpad/src/tools/linux/md2core/minidump-2-core.cc b/chromium/third_party/breakpad/breakpad/src/tools/linux/md2core/minidump-2-core.cc +index 941586e9f6e..49cdc3fc285 100644 +--- a/chromium/third_party/breakpad/breakpad/src/tools/linux/md2core/minidump-2-core.cc ++++ b/chromium/third_party/breakpad/breakpad/src/tools/linux/md2core/minidump-2-core.cc +@@ -76,6 +76,8 @@ + #define ELF_ARCH EM_MIPS + #elif defined(__aarch64__) + #define ELF_ARCH EM_AARCH64 ++#elif defined(__powerpc64__) ++ #define ELF_ARCH EM_PPC64 + #endif + + #if defined(__arm__) +@@ -86,6 +88,8 @@ typedef user_regs user_regs_struct; + #elif defined (__mips__) + // This file-local typedef simplifies the source code. + typedef gregset_t user_regs_struct; ++#elif defined(__powerpc64__) ++typedef struct pt_regs user_regs_struct; + #endif + + using google_breakpad::MDTypeHelper; +@@ -320,6 +324,9 @@ struct CrashedProcess { + #endif + #if defined(__aarch64__) + user_fpsimd_struct fpregs; ++#endif ++#if defined(__powerpc64__) ++ mcontext_t mcontext; + #endif + uintptr_t stack_addr; + const uint8_t* stack; +@@ -534,6 +541,38 @@ ParseThreadRegisters(CrashedProcess::Thread* thread, + thread->mcontext.fpc_eir = rawregs->float_save.fir; + #endif + } ++#elif defined(__powerpc64__) ++static void ++ParseThreadRegisters(CrashedProcess::Thread* thread, ++ const MinidumpMemoryRange& range) { ++ const MDRawContextPPC64* rawregs = range.GetData(0); ++ ++ for (int i = 0; i < MD_CONTEXT_PPC64_GPR_COUNT; i++) ++ thread->mcontext.gp_regs[i] = rawregs->gpr[i]; ++ ++ thread->mcontext.gp_regs[PT_LNK] = rawregs->lr; ++ thread->mcontext.gp_regs[PT_NIP] = rawregs->srr0; ++ thread->mcontext.gp_regs[PT_MSR] = rawregs->srr1; ++ thread->mcontext.gp_regs[PT_CCR] = rawregs->cr; ++ thread->mcontext.gp_regs[PT_XER] = rawregs->xer; ++ thread->mcontext.gp_regs[PT_CTR] = rawregs->ctr; ++ thread->mcontext.v_regs->vrsave = rawregs->vrsave; ++ ++ for (int i = 0; i < MD_FLOATINGSAVEAREA_PPC_FPR_COUNT; i++) ++ thread->mcontext.fp_regs[i] = rawregs->float_save.fpregs[i]; ++ ++ thread->mcontext.fp_regs[NFPREG-1] = rawregs->float_save.fpscr; ++ ++ for (int i = 0; i < MD_VECTORSAVEAREA_PPC_VR_COUNT; i++) { ++ thread->mcontext.v_regs->vrregs[i][0] = rawregs->vector_save.save_vr[i].high >> 32; ++ thread->mcontext.v_regs->vrregs[i][1] = rawregs->vector_save.save_vr[i].high; ++ thread->mcontext.v_regs->vrregs[i][2] = rawregs->vector_save.save_vr[i].low >> 32; ++ thread->mcontext.v_regs->vrregs[i][3] = rawregs->vector_save.save_vr[i].low; ++ } ++ ++ thread->mcontext.v_regs->vscr.vscr_word = rawregs->vector_save.save_vscr.low & 0xFFFFFFFF; ++} ++ + #else + #error "This code has not been ported to your platform yet" + #endif +@@ -622,6 +661,12 @@ ParseSystemInfo(const Options& options, CrashedProcess* crashinfo, + # else + # error "This mips ABI is currently not supported (n32)" + # endif ++#elif defined(__powerpc64__) ++ if (sysinfo->processor_architecture != MD_CPU_ARCHITECTURE_PPC64) { ++ fprintf(stderr, ++ "This version of minidump-2-core only supports PPC64.\n"); ++ exit(1); ++ } + #else + #error "This code has not been ported to your platform yet" + #endif +-- +2.21.1 + + +From 8e95ad6765476b11c4d4746eb9103863bf8683b3 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 13:57:40 +0100 +Subject: [PATCH 08/13] implement crashpad for ppc64 + +--- + .../crashpad/crashpad/CONTRIBUTORS | 1 + + .../crashpad/minidump/minidump_context.h | 64 ++++++ + .../minidump/minidump_context_writer.cc | 50 +++++ + .../minidump/minidump_context_writer.h | 39 ++++ + .../minidump/minidump_context_writer_test.cc | 15 ++ + .../minidump/minidump_misc_info_writer.cc | 2 + + .../crashpad/snapshot/capture_memory.cc | 5 + + .../crashpad/snapshot/cpu_architecture.h | 5 +- + .../crashpad/crashpad/snapshot/cpu_context.cc | 5 + + .../crashpad/crashpad/snapshot/cpu_context.h | 19 ++ + .../snapshot/linux/cpu_context_linux.h | 73 ++++++ + .../snapshot/linux/debug_rendezvous_test.cc | 4 +- + .../linux/exception_snapshot_linux.cc | 63 ++++++ + .../snapshot/linux/exception_snapshot_linux.h | 2 + + .../linux/exception_snapshot_linux_test.cc | 21 ++ + .../snapshot/linux/process_reader_linux.cc | 2 + + .../linux/process_reader_linux_test.cc | 2 + + .../crashpad/snapshot/linux/signal_context.h | 83 +++++++ + .../snapshot/linux/system_snapshot_linux.cc | 11 + + .../snapshot/linux/thread_snapshot_linux.cc | 8 + + .../snapshot/linux/thread_snapshot_linux.h | 2 + + .../crashpad/util/linux/auxiliary_vector.cc | 5 + + .../crashpad/util/linux/ptrace_broker.cc | 4 +- + .../crashpad/crashpad/util/linux/ptracer.cc | 61 +++++ + .../crashpad/util/linux/thread_info.h | 55 +++++ + .../crashpad/util/misc/capture_context.h | 1 + + .../util/misc/capture_context_linux.S | 212 +++++++++++++++++- + .../util/misc/capture_context_test.cc | 2 +- + .../misc/capture_context_test_util_linux.cc | 6 + + .../crashpad/util/posix/signals_test.cc | 12 +- + 30 files changed, 823 insertions(+), 11 deletions(-) + +diff --git a/chromium/third_party/crashpad/crashpad/CONTRIBUTORS b/chromium/third_party/crashpad/crashpad/CONTRIBUTORS +index 8724b7f32f1..8e29424ef63 100644 +--- a/chromium/third_party/crashpad/crashpad/CONTRIBUTORS ++++ b/chromium/third_party/crashpad/crashpad/CONTRIBUTORS +@@ -13,3 +13,4 @@ Mark Mentovai + Robert Sesek + Scott Graham + Joshua Peraza ++Shawn Anastasio +diff --git a/chromium/third_party/crashpad/crashpad/minidump/minidump_context.h b/chromium/third_party/crashpad/crashpad/minidump/minidump_context.h +index 3a3e603cb0d..3118d9e9f9a 100644 +--- a/chromium/third_party/crashpad/crashpad/minidump/minidump_context.h ++++ b/chromium/third_party/crashpad/crashpad/minidump/minidump_context.h +@@ -592,6 +592,70 @@ struct MinidumpContextMIPS64 { + uint64_t fir; + }; + ++//! \brief ppc64-specific flags for MinidumpPPC64::context_flags ++//! Based on minidump_cpu_ppc64.h from breakpad ++enum MinidumpContextPPC64Flags : uint32_t { ++ //! \brief Identifies the context as PPC64. ++ kMinidumpContextPPC64 = 0x01000000, ++ ++ //! \brief Indicates the validity of general purpose registers. ++ //! ++ //! Registers `r0`-`r31`, `nip`, `msr`, `lr`, etc. are valid. ++ kMinidumpContextPPC64Base = kMinidumpContextPPC64 | 0x00000001, ++ ++ //! \brief Indicates the validity of floating point registers. ++ //! ++ //! Registers `fp0`-`fp31`, `fpscr` are valid. ++ kMinidumpContextPPC64Floating = kMinidumpContextPPC64 | 0x00000008, ++ ++ //! \brief Indicates the validity of Altivec/VMX registers. ++ //! ++ //! Registers `v0`-`v31`, `vscr`, `vrsave`. ++ kMinidumpContextPPC64Vector = kMinidumpContextPPC64 | 0x00000020, ++ ++ //! \brief Indicates the validity of all registers ++ kMinidumpContextPPC64All = kMinidumpContextPPC64Base | ++ kMinidumpContextPPC64Floating | ++ kMinidumpContextPPC64Vector ++}; ++ ++//! \brief A PPC64 CPU context carried in a minidump file. ++//! Based on minidump_cpu_ppc64.h from breakpad. ++struct MinidumpContextPPC64 { ++ uint64_t context_flags; ++ ++ //! \brief General purpose registers. ++ uint64_t nip; ++ uint64_t msr; ++ uint64_t regs[32]; ++ uint64_t ccr; ++ uint64_t xer; ++ uint64_t lnk; ++ uint64_t ctr; ++ ++ //! \brief Floating point registers. ++ double fpregs[32]; ++ ++ //! \brief FPU status register. ++ double fpscr; ++ ++ //! \brief Altivec/VMX vector registers. ++ struct { ++ //! \brief Vector registers are 128bits. ++ uint128_struct save_vr[32]; ++ uint128_struct save_vscr; ++ ++ //! \brief Padding included for breakpad compatibiltiy. ++ uint32_t save_pad5[4]; ++ ++ //! \brief VRSAVE register. ++ uint32_t save_vrsave; ++ ++ //! \brief Padding included for breakpad compatibiltiy. ++ uint32_t save_pad6[7]; ++ } vregs; ++}; ++ + } // namespace crashpad + + #endif // CRASHPAD_MINIDUMP_MINIDUMP_CONTEXT_H_ +diff --git a/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer.cc b/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer.cc +index d7e53a4932f..d89eb9e0132 100644 +--- a/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer.cc ++++ b/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer.cc +@@ -101,6 +101,13 @@ MinidumpContextWriter::CreateFromSnapshot(const CPUContext* context_snapshot) { + break; + } + ++ case kCPUArchitecturePPC64: { ++ context = std::make_unique(); ++ reinterpret_cast(context.get()) ++ ->InitalizeFromSnapshot(context_snapshot->ppc64); ++ break; ++ } ++ + default: { + LOG(ERROR) << "unknown context architecture " + << context_snapshot->architecture; +@@ -453,4 +460,47 @@ size_t MinidumpContextMIPS64Writer::ContextSize() const { + return sizeof(context_); + } + ++MinidumpContextPPC64Writer::MinidumpContextPPC64Writer() ++ : MinidumpContextWriter(), context_() { ++ context_.context_flags = kMinidumpContextPPC64; ++} ++ ++MinidumpContextPPC64Writer::~MinidumpContextPPC64Writer() = default; ++ ++void MinidumpContextPPC64Writer::InitalizeFromSnapshot( ++ const CPUContextPPC64* context_snapshot) { ++ DCHECK_EQ(state(), kStateMutable); ++ DCHECK_EQ(context_.context_flags, kMinidumpContextPPC64); ++ ++ context_.context_flags = kMinidumpContextPPC64All; ++ ++ memcpy(context_.regs, context_snapshot->regs, sizeof(context_.regs)); ++ context_.nip = context_snapshot->nip; ++ context_.msr = context_snapshot->msr; ++ context_.ccr = context_snapshot->ccr; ++ context_.xer = context_snapshot->xer; ++ context_.lnk = context_snapshot->lnk; ++ context_.ctr = context_snapshot->ctr; ++ ++ memcpy(context_.fpregs, context_snapshot->fpregs, sizeof(context_.fpregs)); ++ context_.fpscr = context_snapshot->fpscr; ++ ++ memcpy(context_.vregs.save_vr, context_snapshot->vregs.save_vr, ++ sizeof(context_.vregs.save_vr)); ++ memcpy(&context_.vregs.save_vscr, &context_snapshot->vregs.save_vscr, ++ sizeof(context_.vregs.save_vscr)); ++ context_.vregs.save_vrsave = context_snapshot->vregs.save_vrsave; ++} ++ ++bool MinidumpContextPPC64Writer::WriteObject( ++ FileWriterInterface* file_writer) { ++ DCHECK_EQ(state(), kStateWritable); ++ return file_writer->Write(&context_, sizeof(context_)); ++} ++ ++size_t MinidumpContextPPC64Writer::ContextSize() const { ++ DCHECK_GE(state(), kStateFrozen); ++ return sizeof(context_); ++} ++ + } // namespace crashpad +diff --git a/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer.h b/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer.h +index d4ab936ee7f..1d22fc59c97 100644 +--- a/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer.h ++++ b/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer.h +@@ -315,6 +315,45 @@ class MinidumpContextMIPS64Writer final : public MinidumpContextWriter { + DISALLOW_COPY_AND_ASSIGN(MinidumpContextMIPS64Writer); + }; + ++class MinidumpContextPPC64Writer final : public MinidumpContextWriter { ++ public: ++ MinidumpContextPPC64Writer(); ++ ~MinidumpContextPPC64Writer() override; ++ ++ //! \brief Initalizes the MinidumpContextPPC64 based on \a context_snapshot. ++ //! ++ //! \param[in] context_snapshot The context snapshot to use as source data. ++ //! ++ //! \note Valid in #kStateMutable. No mutation of context() may be done before ++ //! calling this method, and it is not normally necessary to alter ++ //! context() after calling this method. ++ void InitalizeFromSnapshot(const CPUContextPPC64* context_snapshot); ++ ++ //! \brief Returns a pointer to the context structure that this object will ++ //! write. ++ //! ++ //! \attention This returns a non-`const` pointer to this object’s private ++ //! data so that a caller can populate the context structure directly. ++ //! This is done because providing setter interfaces to each field in the ++ //! context structure would be unwieldy and cumbersome. Care must be taken ++ //! to populate the context structure correctly. The context structure ++ //! must only be modified while this object is in the #kStateMutable ++ //! state. ++ MinidumpContextPPC64* context() { return &context_; } ++ ++ protected: ++ // MinidumpWritable: ++ bool WriteObject(FileWriterInterface* file_writer) override; ++ ++ // MinidumpContextWriter: ++ size_t ContextSize() const override; ++ ++ private: ++ MinidumpContextPPC64 context_; ++ ++ DISALLOW_COPY_AND_ASSIGN(MinidumpContextPPC64Writer); ++}; ++ + } // namespace crashpad + + #endif // CRASHPAD_MINIDUMP_MINIDUMP_CONTEXT_WRITER_H_ +diff --git a/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer_test.cc b/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer_test.cc +index 3216a906bae..a9fcbe9d8e8 100644 +--- a/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer_test.cc ++++ b/chromium/third_party/crashpad/crashpad/minidump/minidump_context_writer_test.cc +@@ -213,6 +213,21 @@ TEST(MinidumpContextWriter, MIPS64_FromSnapshot) { + context, ExpectMinidumpContextMIPS64, kSeed); + } + ++TEST(MinidumpContextWriter, PPC64_Zeros) { ++ EmptyContextTest( ++ ExpectMinidumpContextPPC64); ++} ++ ++TEST(MinidumpContextWriter, PPC64_FromSnapshot) { ++ constexpr uint32_t kSeed = 64; ++ CPUContextPPC64 context_ppc64; ++ CPUContext context; ++ context.ppc64 = &context_ppc64; ++ InitializeCPUContextPPC64(&context, kSeed); ++ FromSnapshotTest( ++ context, ExpectMinidumpContextPPC64, kSeed); ++} ++ + } // namespace + } // namespace test + } // namespace crashpad +diff --git a/chromium/third_party/crashpad/crashpad/minidump/minidump_misc_info_writer.cc b/chromium/third_party/crashpad/crashpad/minidump/minidump_misc_info_writer.cc +index a13407605f7..95dc9252406 100644 +--- a/chromium/third_party/crashpad/crashpad/minidump/minidump_misc_info_writer.cc ++++ b/chromium/third_party/crashpad/crashpad/minidump/minidump_misc_info_writer.cc +@@ -126,6 +126,8 @@ std::string MinidumpMiscInfoDebugBuildString() { + static constexpr char kCPU[] = "mips"; + #elif defined(ARCH_CPU_MIPS64EL) + static constexpr char kCPU[] = "mips64"; ++#elif defined(ARCH_CPU_PPC64) ++ static constexpr char kCPU[] = "ppc64"; + #else + #error define kCPU for this CPU + #endif +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/capture_memory.cc b/chromium/third_party/crashpad/crashpad/snapshot/capture_memory.cc +index a51626ccdc0..61e0b20a17c 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/capture_memory.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/capture_memory.cc +@@ -111,6 +111,11 @@ void CaptureMemory::PointedToByContext(const CPUContext& context, + for (size_t i = 0; i < base::size(context.mipsel->regs); ++i) { + MaybeCaptureMemoryAround(delegate, context.mipsel->regs[i]); + } ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ MaybeCaptureMemoryAround(delegate, context.ppc64->nip); ++ for (size_t i = 0; i < base::size(context.ppc64->regs); ++i) { ++ MaybeCaptureMemoryAround(delegate, context.ppc64->regs[i]); ++ } + #else + #error Port. + #endif +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/cpu_architecture.h b/chromium/third_party/crashpad/crashpad/snapshot/cpu_architecture.h +index 811a7209587..f4f83981dfd 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/cpu_architecture.h ++++ b/chromium/third_party/crashpad/crashpad/snapshot/cpu_architecture.h +@@ -43,7 +43,10 @@ enum CPUArchitecture { + kCPUArchitectureMIPSEL, + + //! \brief 64-bit MIPSEL. +- kCPUArchitectureMIPS64EL ++ kCPUArchitectureMIPS64EL, ++ ++ //! \brief 64-bit PPC64. ++ kCPUArchitecturePPC64 + }; + + } // namespace crashpad +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/cpu_context.cc b/chromium/third_party/crashpad/crashpad/snapshot/cpu_context.cc +index 6fb8d7e719f..b01f7cad11f 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/cpu_context.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/cpu_context.cc +@@ -169,6 +169,8 @@ uint64_t CPUContext::InstructionPointer() const { + return arm->pc; + case kCPUArchitectureARM64: + return arm64->pc; ++ case kCPUArchitecturePPC64: ++ return ppc64->nip; + default: + NOTREACHED(); + return ~0ull; +@@ -185,6 +187,8 @@ uint64_t CPUContext::StackPointer() const { + return arm->sp; + case kCPUArchitectureARM64: + return arm64->sp; ++ case kCPUArchitecturePPC64: ++ return ppc64->regs[1]; + default: + NOTREACHED(); + return ~0ull; +@@ -196,6 +200,7 @@ bool CPUContext::Is64Bit() const { + case kCPUArchitectureX86_64: + case kCPUArchitectureARM64: + case kCPUArchitectureMIPS64EL: ++ case kCPUArchitecturePPC64: + return true; + case kCPUArchitectureX86: + case kCPUArchitectureARM: +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/cpu_context.h b/chromium/third_party/crashpad/crashpad/snapshot/cpu_context.h +index fb23c4679f0..eebede63c6b 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/cpu_context.h ++++ b/chromium/third_party/crashpad/crashpad/snapshot/cpu_context.h +@@ -352,6 +352,24 @@ struct CPUContextMIPS64 { + uint64_t fir; + }; + ++//! \brief A context structure carrying PPC64 CPU state. ++struct CPUContextPPC64 { ++ uint64_t nip; ++ uint64_t msr; ++ uint64_t regs[32]; ++ uint64_t ccr; ++ uint64_t xer; ++ uint64_t lnk; ++ uint64_t ctr; ++ double fpregs[32]; ++ double fpscr; ++ struct { ++ uint128_struct save_vr[32]; ++ uint128_struct save_vscr; ++ uint32_t save_vrsave; ++ } vregs; ++}; ++ + //! \brief A context structure capable of carrying the context of any supported + //! CPU architecture. + struct CPUContext { +@@ -382,6 +400,7 @@ struct CPUContext { + CPUContextARM64* arm64; + CPUContextMIPS* mipsel; + CPUContextMIPS64* mips64; ++ CPUContextPPC64* ppc64; + }; + }; + +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/cpu_context_linux.h b/chromium/third_party/crashpad/crashpad/snapshot/linux/cpu_context_linux.h +index 37fbc4325ce..cf4ef7ef96e 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/cpu_context_linux.h ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/cpu_context_linux.h +@@ -15,6 +15,7 @@ + #ifndef CRASHPAD_SNAPSHOT_LINUX_CPU_CONTEXT_LINUX_H_ + #define CRASHPAD_SNAPSHOT_LINUX_CPU_CONTEXT_LINUX_H_ + ++#include + #include "build/build_config.h" + #include "snapshot/cpu_context.h" + #include "snapshot/linux/signal_context.h" +@@ -174,6 +175,78 @@ void InitializeCPUContextMIPS( + + #endif // ARCH_CPU_MIPS_FAMILY || DOXYGEN + ++#if defined(ARCH_CPU_PPC64_FAMILY) || DOXYGEN ++ ++//! \brief Initalizes a CPUContextPPC64 structure from native context ++//! structures on Linux. ++//! ++//! \param[in] thread_context The native thread context. ++//! \param[in] float_context The native float context. ++//! \param[in] vector_context The native vector context. ++//! \param[out] context The CPUContextPPC64 structure to initalize. ++template ++void InitializeCPUContextPPC64( ++ const ThreadContext::t64_t& thread_context, ++ const FloatContext::f64_t& float_context, ++ const VectorContext::v64_t& vector_context, ++ typename Traits::CPUContext* context) { ++ ++ memcpy(context->regs, thread_context.gpr, sizeof(context->regs)); ++ context->nip = thread_context.nip; ++ context->msr = thread_context.msr; ++ context->ccr = thread_context.ccr; ++ context->xer = thread_context.xer; ++ context->lnk = thread_context.lnk; ++ context->ctr = thread_context.ctr; ++ ++ memcpy(context->fpregs, float_context.fpregs, sizeof(context->fpregs)); ++ context->fpscr = float_context.fpscr; ++ ++ for (uint8_t i = 0; i < 32; i++) { ++ context->vregs.save_vr[i] = { ++ (((uint64_t)vector_context.vrregs[i][0]) << 32) | ++ vector_context.vrregs[i][1], ++ (((uint64_t)vector_context.vrregs[i][2]) << 32) | ++ vector_context.vrregs[i][3] ++ }; ++ } ++ context->vregs.save_vrsave = vector_context.vrsave; ++ context->vregs.save_vscr = {0, (uint64_t)vector_context.vscr.vscr_word}; ++} ++ ++template ++void InitializeCPUContextPPC64( ++ const SignalThreadContext64 &thread_context, ++ const SignalFloatContext64 &float_context, ++ const SignalVectorContext64 &vector_context, ++ typename Traits::CPUContext* context) { ++ ++ memcpy(context->regs, thread_context.regs, sizeof(context->regs)); ++ context->nip = thread_context.nip; ++ context->msr = thread_context.msr; ++ context->ccr = thread_context.ccr; ++ context->xer = thread_context.xer; ++ context->lnk = thread_context.lnk; ++ context->ctr = thread_context.ctr; ++ ++ memcpy(context->fpregs, float_context.regs, sizeof(context->fpregs)); ++ context->fpscr = float_context.fpscr; ++ ++ for (uint8_t i = 0; i < 32; i++) { ++ context->vregs.save_vr[i] = { ++ (((uint64_t)vector_context.vrregs[i][0]) << 32) | ++ vector_context.vrregs[i][1], ++ (((uint64_t)vector_context.vrregs[i][2]) << 32) | ++ vector_context.vrregs[i][3] ++ }; ++ } ++ context->vregs.save_vrsave = vector_context.vrsave; ++ context->vregs.save_vscr = {0, (uint64_t)vector_context.vscr.vscr_word}; ++} ++ ++ ++#endif ++ + } // namespace internal + } // namespace crashpad + +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/debug_rendezvous_test.cc b/chromium/third_party/crashpad/crashpad/snapshot/linux/debug_rendezvous_test.cc +index be22c903133..c5df23d1b4d 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/debug_rendezvous_test.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/debug_rendezvous_test.cc +@@ -159,9 +159,11 @@ void TestAgainstTarget(PtraceConnection* connection) { + const bool is_vdso_mapping = + device == 0 && inode == 0 && mapping_name == "[vdso]"; + static constexpr char kPrefix[] = "linux-vdso.so."; ++ static constexpr char kPrefix64[] = "linux-vdso64.so."; + return is_vdso_mapping == + (module_name.empty() || +- module_name.compare(0, strlen(kPrefix), kPrefix) == 0); ++ module_name.compare(0, strlen(kPrefix), kPrefix) == 0 || ++ module_name.compare(0, strlen(kPrefix64), kPrefix64) == 0); + }, + module_mapping->name, + module_mapping->device, +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux.cc b/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux.cc +index cd40b3b12d6..6bcf23b6ffe 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux.cc +@@ -323,6 +323,69 @@ bool ExceptionSnapshotLinux::ReadContext( + reader, context_address, context_.mips64); + } + ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ ++template ++static bool ReadContext(ProcessReaderLinux* reader, ++ LinuxVMAddress context_address, ++ typename Traits::CPUContext* dest_context) { ++ const ProcessMemory* memory = reader->Memory(); ++ ++ LinuxVMAddress gp_regs_address = context_address + ++ offsetof(UContext, mcontext) + ++ offsetof(typename Traits::MContext, gp_regs); ++ ++ typename Traits::SignalThreadContext thread_context; ++ if (!memory->Read(gp_regs_address, sizeof(thread_context), &thread_context)) { ++ LOG(ERROR) << "Couldn't read gp_regs!"; ++ return false; ++ } ++ ++ LinuxVMAddress fp_regs_address = context_address + ++ offsetof(UContext, mcontext) + ++ offsetof(typename Traits::MContext, fp_regs); ++ ++ typename Traits::SignalFloatContext fp_context; ++ if (!memory->Read(fp_regs_address, sizeof(fp_context), &fp_context)) { ++ LOG(ERROR) << "Couldn't read fp_regs!"; ++ return false; ++ } ++ ++ LinuxVMAddress v_regs_ptr_address = context_address + ++ offsetof(UContext, mcontext) + ++ offsetof(typename Traits::MContext, vmx_reserve) + 8; ++ ++ typename Traits::SignalVectorContext v_context; ++ if (!memory->Read(v_regs_ptr_address, sizeof(v_context), &v_context)) { ++ LOG(ERROR) << "Couldn't read v_regs!"; ++ return false; ++ } ++ ++ InitializeCPUContextPPC64(thread_context, fp_context, ++ v_context, dest_context); ++ ++ return true; ++} ++ ++template<> ++bool ExceptionSnapshotLinux::ReadContext( ++ ProcessReaderLinux* reader, ++ LinuxVMAddress context_address) { ++ context_.architecture = kCPUArchitecturePPC64; ++ context_.ppc64 = &context_union_.ppc64; ++ ++ return internal::ReadContext( ++ reader, context_address, context_.ppc64); ++} ++ ++template<> ++bool ExceptionSnapshotLinux::ReadContext( ++ ProcessReaderLinux* reader, ++ LinuxVMAddress context_address) { ++ // PPC64 is 64-bit ++ return false; ++} ++ + #endif // ARCH_CPU_X86_FAMILY + + bool ExceptionSnapshotLinux::Initialize(ProcessReaderLinux* process_reader, +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux.h b/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux.h +index ea0cd21066d..e42df520ff4 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux.h ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux.h +@@ -84,6 +84,8 @@ class ExceptionSnapshotLinux final : public ExceptionSnapshot { + #elif defined(ARCH_CPU_MIPS_FAMILY) + CPUContextMIPS mipsel; + CPUContextMIPS64 mips64; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ CPUContextPPC64 ppc64; + #endif + } context_union_; + CPUContext context_; +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux_test.cc b/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux_test.cc +index e4ff1ab79fb..25534dd0876 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux_test.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/exception_snapshot_linux_test.cc +@@ -296,7 +296,28 @@ void ExpectContext(const CPUContext& actual, const NativeCPUContext& expected) { + 0); + #undef CPU_ARCH_NAME + } ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++using NativeCPUContext = ucontext_t; ++ ++void InitializeContext(NativeCPUContext* context) { ++ for (size_t reg = 0; reg < 32; ++reg) { ++ context->uc_mcontext.gp_regs[reg] = reg; ++ } ++ ++ memset(&context->uc_mcontext.fp_regs, 44, ++ sizeof(context->uc_mcontext.fp_regs)); ++} + ++void ExpectContext(const CPUContext& actual, const NativeCPUContext& expected) { ++ EXPECT_EQ(actual.architecture, kCPUArchitecturePPC64); ++ ++ for (size_t reg = 0; reg < 32; ++reg) { ++ EXPECT_EQ(actual.ppc64->regs[reg], expected.uc_mcontext.gp_regs[reg]); ++ } ++ ++ EXPECT_EQ(memcmp(actual.ppc64->fpregs, expected.uc_mcontext.fp_regs, ++ sizeof(actual.ppc64->fpregs)), 0); ++} + #else + #error Port. + #endif +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/process_reader_linux.cc b/chromium/third_party/crashpad/crashpad/snapshot/linux/process_reader_linux.cc +index c1d6c40f7a9..8923b171021 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/process_reader_linux.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/process_reader_linux.cc +@@ -108,6 +108,8 @@ void ProcessReaderLinux::Thread::InitializeStack(ProcessReaderLinux* reader) { + #elif defined(ARCH_CPU_MIPS_FAMILY) + stack_pointer = reader->Is64Bit() ? thread_info.thread_context.t64.regs[29] + : thread_info.thread_context.t32.regs[29]; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ stack_pointer = thread_info.thread_context.t64.gpr[1]; + #else + #error Port. + #endif +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/process_reader_linux_test.cc b/chromium/third_party/crashpad/crashpad/snapshot/linux/process_reader_linux_test.cc +index e2e5566c871..ee194c7c0e9 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/process_reader_linux_test.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/process_reader_linux_test.cc +@@ -591,6 +591,8 @@ bool WriteTestModule(const base::FilePath& module_path) { + module.ehdr.e_machine = EM_AARCH64; + #elif defined(ARCH_CPU_MIPSEL) || defined(ARCH_CPU_MIPS64EL) + module.ehdr.e_machine = EM_MIPS; ++#elif defined(ARCH_CPU_PPC64) ++ module.ehdr.e_machine = EM_PPC64; + #endif + + module.ehdr.e_version = EV_CURRENT; +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/signal_context.h b/chromium/third_party/crashpad/crashpad/snapshot/linux/signal_context.h +index 110024680bd..8e335a0960c 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/signal_context.h ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/signal_context.h +@@ -422,6 +422,89 @@ static_assert(offsetof(UContext, mcontext.fpregs) == + "context offset mismatch"); + #endif + ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ ++struct SignalThreadContext64 { ++ uint64_t regs[32]; ++ uint64_t nip; ++ uint64_t msr; ++ uint64_t orig_r3; ++ uint64_t ctr; ++ uint64_t lnk; ++ uint64_t xer; ++ uint64_t ccr; ++ uint64_t softe; ++ uint64_t trap; ++ uint64_t dar; ++ uint64_t dsisr; ++ uint64_t result; ++ uint64_t dscr; ++ uint64_t fpr0[3]; ++}; ++ ++struct SignalFloatContext64 { ++ double regs[32]; ++ double fpscr; ++}; ++ ++struct SignalVectorContext64 { ++ int32_t vrregs[32][4]; ++ struct { ++ int32_t __pad[3]; ++ int32_t vscr_word; ++ } vscr; ++ int32_t vrsave; ++ int32_t __pad[3]; ++} __attribute__((__aligned__(16))); ++ ++ ++#pragma pack(pop) ++struct MContext64 { ++ uint64_t reserved[4]; ++ int32_t signal; ++ int32_t __pad0; ++ uint64_t handler; ++ uint64_t oldmask; ++ uint64_t pt_regs_ptr; ++ SignalThreadContext64 gp_regs; ++ SignalFloatContext64 fp_regs; ++ SignalVectorContext64 *v_regs; ++ int64_t vmx_reserve[69]; ++}; ++ ++struct ContextTraits64 : public Traits64 { ++ using MContext = MContext64; ++ using SignalThreadContext = SignalThreadContext64; ++ using SignalFloatContext = SignalFloatContext64; ++ using SignalVectorContext = SignalVectorContext64; ++ using CPUContext = CPUContextPPC64; ++}; ++ ++struct ContextTraits32 : public Traits32 {}; ++ ++struct UContext { ++ uint64_t flags; ++ uint64_t link; ++ SignalStack stack; ++ Sigset sigmask; ++ MContext64 mcontext; ++}; ++#pragma pack(push, 1) ++ ++static_assert(sizeof(UContext) == sizeof(ucontext_t), ++ "ucontext_t size mismatch"); ++static_assert(sizeof(MContext64) == sizeof(mcontext_t), ++ "mcontext_t size mismatch"); ++static_assert(sizeof(SignalThreadContext64) == sizeof(gregset_t), ++ "gregset_t size mismatch"); ++static_assert(sizeof(SignalFloatContext64) == sizeof(fpregset_t), ++ "fpregset_t size mismatch"); ++static_assert(sizeof(SignalVectorContext64) == sizeof(_libc_vrstate), ++ "vrstate size mismatch"); ++static_assert(offsetof(UContext, mcontext) == ++ offsetof(ucontext_t, uc_mcontext), "mcontext offset mismatch"); ++static_assert(offsetof(MContext64, gp_regs) == ++ offsetof(mcontext_t, gp_regs), "gp_regs offset mismatch"); + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/system_snapshot_linux.cc b/chromium/third_party/crashpad/crashpad/snapshot/linux/system_snapshot_linux.cc +index 8564d3d4557..b690ecd48fa 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/system_snapshot_linux.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/system_snapshot_linux.cc +@@ -203,6 +203,8 @@ CPUArchitecture SystemSnapshotLinux::GetCPUArchitecture() const { + #elif defined(ARCH_CPU_MIPS_FAMILY) + return process_reader_->Is64Bit() ? kCPUArchitectureMIPS64EL + : kCPUArchitectureMIPSEL; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ return kCPUArchitecturePPC64; + #else + #error port to your architecture + #endif +@@ -218,6 +220,9 @@ uint32_t SystemSnapshotLinux::CPURevision() const { + #elif defined(ARCH_CPU_MIPS_FAMILY) + // Not implementable on MIPS + return 0; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ // Not yet implemented on PPC64 ++ return 0; + #else + #error port to your architecture + #endif +@@ -238,6 +243,9 @@ std::string SystemSnapshotLinux::CPUVendor() const { + #elif defined(ARCH_CPU_MIPS_FAMILY) + // Not implementable on MIPS + return std::string(); ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ // Not yet implemented on PPC64 ++ return std::string(); + #else + #error port to your architecture + #endif +@@ -371,6 +379,9 @@ bool SystemSnapshotLinux::NXEnabled() const { + #elif defined(ARCH_CPU_MIPS_FAMILY) + // Not implementable on MIPS + return false; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ // Not yet implemented on PPC64 ++ return false; + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/thread_snapshot_linux.cc b/chromium/third_party/crashpad/crashpad/snapshot/linux/thread_snapshot_linux.cc +index f40c78e8eca..5195c080f07 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/thread_snapshot_linux.cc ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/thread_snapshot_linux.cc +@@ -186,6 +186,14 @@ bool ThreadSnapshotLinux::Initialize(ProcessReaderLinux* process_reader, + thread.thread_info.float_context.f32, + context_.mipsel); + } ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ context_.architecture = kCPUArchitecturePPC64; ++ context_.ppc64 = &context_union_.ppc64; ++ InitializeCPUContextPPC64( ++ thread.thread_info.thread_context.t64, ++ thread.thread_info.float_context.f64, ++ thread.thread_info.vector_context.v64, ++ context_.ppc64); + #else + #error Port. + #endif +diff --git a/chromium/third_party/crashpad/crashpad/snapshot/linux/thread_snapshot_linux.h b/chromium/third_party/crashpad/crashpad/snapshot/linux/thread_snapshot_linux.h +index 17e471f3272..cea09d0741b 100644 +--- a/chromium/third_party/crashpad/crashpad/snapshot/linux/thread_snapshot_linux.h ++++ b/chromium/third_party/crashpad/crashpad/snapshot/linux/thread_snapshot_linux.h +@@ -68,6 +68,8 @@ class ThreadSnapshotLinux final : public ThreadSnapshot { + #elif defined(ARCH_CPU_MIPS_FAMILY) + CPUContextMIPS mipsel; + CPUContextMIPS64 mips64; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ CPUContextPPC64 ppc64; + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY +diff --git a/chromium/third_party/crashpad/crashpad/util/linux/auxiliary_vector.cc b/chromium/third_party/crashpad/crashpad/util/linux/auxiliary_vector.cc +index d3d5ebdfb9f..3fd730cb520 100644 +--- a/chromium/third_party/crashpad/crashpad/util/linux/auxiliary_vector.cc ++++ b/chromium/third_party/crashpad/crashpad/util/linux/auxiliary_vector.cc +@@ -56,6 +56,11 @@ bool AuxiliaryVector::Read(PtraceConnection* connection) { + if (type == AT_IGNORE) { + continue; + } ++#if defined(ARCH_CPU_PPC64_FAMILY) ++ if (type == AT_IGNOREPPC) { ++ continue; ++ } ++#endif + if (!MapInsertOrReplace(&values_, type, value, nullptr)) { + LOG(ERROR) << "duplicate auxv entry"; + return false; +diff --git a/chromium/third_party/crashpad/crashpad/util/linux/ptrace_broker.cc b/chromium/third_party/crashpad/crashpad/util/linux/ptrace_broker.cc +index 4d7e4cedaa0..b9e08950972 100644 +--- a/chromium/third_party/crashpad/crashpad/util/linux/ptrace_broker.cc ++++ b/chromium/third_party/crashpad/crashpad/util/linux/ptrace_broker.cc +@@ -93,8 +93,8 @@ int PtraceBroker::Run() { + } + + bool PtraceBroker::AllocateAttachments() { +- constexpr size_t page_size = 4096; +- constexpr size_t alloc_size = ++ static size_t page_size = getpagesize(); ++ size_t alloc_size = + (sizeof(ScopedPtraceAttach) + page_size - 1) & ~(page_size - 1); + void* alloc = sbrk(alloc_size); + if (reinterpret_cast(alloc) == -1) { +diff --git a/chromium/third_party/crashpad/crashpad/util/linux/ptracer.cc b/chromium/third_party/crashpad/crashpad/util/linux/ptracer.cc +index c6c92299464..c770b6b6fe7 100644 +--- a/chromium/third_party/crashpad/crashpad/util/linux/ptracer.cc ++++ b/chromium/third_party/crashpad/crashpad/util/linux/ptracer.cc +@@ -394,6 +394,64 @@ bool GetThreadArea64(pid_t tid, + return true; + } + ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++// PPC64 has had HAVE_ARCH_TRACEHOOK set since 2.6.27 (even before x86 had it). ++// That means we can simply use PTRACE_GETREGESET. ++ ++template ++bool GetRegisterSet(pid_t tid, int set, Destination* dest, bool can_log) { ++ iovec iov; ++ iov.iov_base = reinterpret_cast(dest); ++ iov.iov_len = sizeof(*dest); ++ if (ptrace(PTRACE_GETREGSET, tid, reinterpret_cast(set), &iov) != 0) { ++ PLOG_IF(ERROR, can_log) << "ptrace"; ++ return false; ++ } ++ if (iov.iov_len != sizeof(*dest)) { ++ LOG_IF(ERROR, can_log) << "Unexpected registers size"; ++ return false; ++ } ++ return true; ++} ++ ++bool GetVectorRegisters64(pid_t tid, ++ VectorContext* context, ++ bool can_log) { ++ return GetRegisterSet(tid, NT_PPC_VMX, &context->v64, can_log); ++} ++ ++bool GetFloatingPointRegisters64(pid_t tid, ++ FloatContext* context, ++ bool can_log) { ++ return GetRegisterSet(tid, NT_PRFPREG, &context->f64, can_log); ++} ++ ++bool GetThreadArea64(pid_t tid, ++ const ThreadContext& context, ++ LinuxVMAddress* address, ++ bool can_log) { ++ // PPC64 doesn't have PTRACE_GET_THREAD_AREA since the thread pointer ++ // is stored in GPR 13. ++ ThreadContext::t64_t tc; ++ if (!GetRegisterSet(tid, NT_PRSTATUS, &tc, can_log)) { ++ LOG_IF(ERROR, can_log) << "Unable to get thread pointer!"; ++ return false; ++ } ++ ++ *address = tc.gpr[13]; ++ ++ return true; ++} ++ ++// Stubs for 32-bit functions not applicable on PPC64 ++bool GetFloatingPointRegisters32(pid_t tid, ++ FloatContext* context, ++ bool can_log) { return false; } ++bool GetThreadArea32(pid_t tid, ++ const ThreadContext &context, ++ LinuxVMAddress *address, ++ bool can_log) { return false; } ++ + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY +@@ -486,6 +544,9 @@ bool Ptracer::GetThreadInfo(pid_t tid, ThreadInfo* info) { + if (is_64_bit_) { + return GetGeneralPurposeRegisters64(tid, &info->thread_context, can_log_) && + GetFloatingPointRegisters64(tid, &info->float_context, can_log_) && ++#if defined(ARCH_CPU_PPC64_FAMILY) ++ GetVectorRegisters64(tid, &info->vector_context, can_log_) && ++#endif + GetThreadArea64(tid, + info->thread_context, + &info->thread_specific_data_address, +diff --git a/chromium/third_party/crashpad/crashpad/util/linux/thread_info.h b/chromium/third_party/crashpad/crashpad/util/linux/thread_info.h +index 5b55c24a76d..dea0d1f39eb 100644 +--- a/chromium/third_party/crashpad/crashpad/util/linux/thread_info.h ++++ b/chromium/third_party/crashpad/crashpad/util/linux/thread_info.h +@@ -28,6 +28,10 @@ + #include + #endif + ++#if defined(ARCH_CPU_PPC64_FAMILY) ++#include ++#endif ++ + namespace crashpad { + + //! \brief The set of general purpose registers for an architecture family. +@@ -79,6 +83,8 @@ union ThreadContext { + uint32_t cp0_status; + uint32_t cp0_cause; + uint32_t padding1_; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ // PPC64 is 64-bit + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY +@@ -132,6 +138,21 @@ union ThreadContext { + uint64_t cp0_badvaddr; + uint64_t cp0_status; + uint64_t cp0_cause; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ // Reflects struct pt_regs in asm/ptrace.h. ++ uint64_t gpr[32]; ++ uint64_t nip; ++ uint64_t msr; ++ uint64_t orig_gpr3; ++ uint64_t ctr; ++ uint64_t lnk; ++ uint64_t xer; ++ uint64_t ccr; ++ uint64_t softe; ++ uint64_t trap; ++ uint64_t dar; ++ uint64_t dsisr; ++ uint64_t result; + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY +@@ -143,6 +164,8 @@ union ThreadContext { + using NativeThreadContext = user_regs; + #elif defined(ARCH_CPU_MIPS_FAMILY) + // No appropriate NativeThreadsContext type available for MIPS ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ using NativeThreadContext = struct pt_regs; + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY || ARCH_CPU_ARM64 +@@ -218,6 +241,9 @@ union FloatContext { + } fpregs[32]; + uint32_t fpcsr; + uint32_t fpu_id; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ // Crashpad's PPC support is 64-bit only, so this ++ // 32bit-only struct is declared as empty. + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY +@@ -252,6 +278,10 @@ union FloatContext { + double fpregs[32]; + uint32_t fpcsr; + uint32_t fpu_id; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ // Reflects fpregset_t in sys/ucontext.h ++ double fpregs[32]; ++ double fpscr; + #else + #error Port. + #endif // ARCH_CPU_X86_FAMILY +@@ -280,6 +310,8 @@ union FloatContext { + static_assert(sizeof(f64) == sizeof(user_fpsimd_struct), "Size mismatch"); + #elif defined(ARCH_CPU_MIPS_FAMILY) + // No appropriate floating point context native type for available MIPS. ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ static_assert(sizeof(f64) == sizeof(fpregset_t), "Size mismatch"); + #else + #error Port. + #endif // ARCH_CPU_X86 +@@ -287,6 +319,26 @@ union FloatContext { + static_assert(std::is_standard_layout::value, + "Not standard layout"); + ++//! \brief The vector registers used for an architecture family ++union VectorContext { ++ struct v32_t {} v32; ++#if defined(ARCH_CPU_PPC64_FAMILY) ++ __attribute__((__aligned__(16))) // Vector context must be doubleword aligned. ++#endif ++ struct v64_t { ++#if defined(ARCH_CPU_PPC64_FAMILY) ++ // Reflects vrregset_t in sys/ucontext.h ++ uint32_t vrregs[32][4]; ++ struct { ++ uint32_t __pad[3]; ++ uint32_t vscr_word; ++ } vscr; ++ uint32_t vrsave; ++ uint32_t __pad[3]; ++#endif ++ } v64; ++}; ++ + //! \brief A collection of `ptrace`-able information about a thread. + struct ThreadInfo { + ThreadInfo(); +@@ -298,6 +350,9 @@ struct ThreadInfo { + //! \brief The floating point registers for the thread. + FloatContext float_context; + ++ //! \brief (Optional) The vector registers used for the thread. ++ VectorContext vector_context; ++ + //! \brief The thread-local storage address for the thread. + LinuxVMAddress thread_specific_data_address; + }; +diff --git a/chromium/third_party/crashpad/crashpad/util/misc/capture_context.h b/chromium/third_party/crashpad/crashpad/util/misc/capture_context.h +index 541589dfde2..5b0fc8218c0 100644 +--- a/chromium/third_party/crashpad/crashpad/util/misc/capture_context.h ++++ b/chromium/third_party/crashpad/crashpad/util/misc/capture_context.h +@@ -66,6 +66,7 @@ using NativeCPUContext = ucontext_t; + //! macOS/Linux/Fuchsia | x86_64 | `%%rdi` + //! Linux | ARM/ARM64 | `r0`/`x0` + //! Linux | MIPS/MIPS64 | `$a0` ++//! Linux | PPC64 | `r3` + //! + //! Additionally, the value `LR` on ARM/ARM64 will be the return address of + //! this function. +diff --git a/chromium/third_party/crashpad/crashpad/util/misc/capture_context_linux.S b/chromium/third_party/crashpad/crashpad/util/misc/capture_context_linux.S +index 657a979a76e..8b1d139e8b7 100644 +--- a/chromium/third_party/crashpad/crashpad/util/misc/capture_context_linux.S ++++ b/chromium/third_party/crashpad/crashpad/util/misc/capture_context_linux.S +@@ -28,7 +28,7 @@ + .globl CAPTURECONTEXT_SYMBOL2 + #if defined(__i386__) || defined(__x86_64__) + .balign 16, 0x90 +-#elif defined(__arm__) || defined(__aarch64__) || defined(__mips__) ++#elif defined(__arm__) || defined(__aarch64__) || defined(__mips__) || defined(__powerpc64__) + .balign 4, 0x0 + #endif + +@@ -419,4 +419,214 @@ CAPTURECONTEXT_SYMBOL2: + jr $ra + + .set at ++#elif defined(__powerpc64__) ++ // Store r0-r31 ++ std 0, 0xe8(3) // context->uc_mcontext.gp_regs[0] ++ std 1, 0xf0(3) // context->uc_mcontext.gp_regs[1] ++ std 2, 0xf8(3) // context->uc_mcontext.gp_regs[2] ++ // note that r3's original value was lost ++ std 3, 0x100(3) // context->uc_mcontext.gp_regs[3] ++ std 4, 0x108(3) // context->uc_mcontext.gp_regs[4] ++ std 5, 0x110(3) // context->uc_mcontext.gp_regs[5] ++ std 6, 0x118(3) // context->uc_mcontext.gp_regs[6] ++ std 7, 0x120(3) // context->uc_mcontext.gp_regs[7] ++ std 8, 0x128(3) // context->uc_mcontext.gp_regs[8] ++ std 9, 0x130(3) // context->uc_mcontext.gp_regs[9] ++ std 10, 0x138(3) // context->uc_mcontext.gp_regs[10] ++ std 11, 0x140(3) // context->uc_mcontext.gp_regs[11] ++ std 12, 0x148(3) // context->uc_mcontext.gp_regs[12] ++ std 13, 0x150(3) // context->uc_mcontext.gp_regs[13] ++ std 14, 0x158(3) // context->uc_mcontext.gp_regs[14] ++ std 15, 0x160(3) // context->uc_mcontext.gp_regs[15] ++ std 16, 0x168(3) // context->uc_mcontext.gp_regs[16] ++ std 17, 0x170(3) // context->uc_mcontext.gp_regs[17] ++ std 18, 0x178(3) // context->uc_mcontext.gp_regs[18] ++ std 19, 0x180(3) // context->uc_mcontext.gp_regs[19] ++ std 20, 0x188(3) // context->uc_mcontext.gp_regs[20] ++ std 21, 0x190(3) // context->uc_mcontext.gp_regs[21] ++ std 22, 0x198(3) // context->uc_mcontext.gp_regs[22] ++ std 23, 0x1a0(3) // context->uc_mcontext.gp_regs[23] ++ std 24, 0x1a8(3) // context->uc_mcontext.gp_regs[24] ++ std 25, 0x1b0(3) // context->uc_mcontext.gp_regs[25] ++ std 26, 0x1b8(3) // context->uc_mcontext.gp_regs[26] ++ std 27, 0x1c0(3) // context->uc_mcontext.gp_regs[27] ++ std 28, 0x1c8(3) // context->uc_mcontext.gp_regs[28] ++ std 29, 0x1d0(3) // context->uc_mcontext.gp_regs[29] ++ std 30, 0x1d8(3) // context->uc_mcontext.gp_regs[30] ++ std 31, 0x1e0(3) // context->uc_mcontext.gp_regs[31] ++ ++ // For NIP, we can use the value in the link register ++ mflr 0 ++ std 0, 0x1e8(3) // context->uc_mcontext.gp_regs[PT_NIP] ++ ++ // CTR ++ mfctr 0 ++ std 0, 0x200(3) // context->uc_mcontext.gp_regs[PT_CTR] ++ ++ // For LNK, we'll use the caller's LR save area (2 stack frames up). ++ // r4 can be used as a scratch register since it has already been saved. ++ ld 4, 0(1) ++ ld 4, 16(4) ++ std 4, 0x208(3) // context->uc_mcontext.gp_regs[PT_LNK] ++ ++ // XER ++ mfxer 0 ++ std 0, 0x210(3) // context->uc_mcontext.gp_regs[PT_XER] ++ ++ // CCR ++ mfcr 0 ++ std 0, 0x218(3) // context->uc_mcontext.gp_regs[PT_CCR] ++ ++ // MSR, orig_r3, MQ, TRAP, DAR, DSISR, RESULT, DSCR, ++ // not used or not relevant, zero them out. ++ li 4, 0 ++ std 4, 0x1f0(3) // context->uc_mcontext.gp_regs[PT_MSR] ++ std 4, 0x1f8(3) // context->uc_mcontext.gp_regs[PT_ORIG_R3] ++ std 4, 0x220(3) // context->uc_mcontext.gp_regs[PT_MQ] ++ std 4, 0x228(3) // context->uc_mcontext.gp_regs[PT_TRAP] ++ std 4, 0x230(3) // context->uc_mcontext.gp_regs[PT_DAR] ++ std 4, 0x238(3) // context->uc_mcontext.gp_regs[PT_DSISR] ++ std 4, 0x240(3) // context->uc_mcontext.gp_regs[PT_RESULT] ++ std 4, 0x248(3) // context->uc_mcontext.gp_regs[PT_DSCR] ++ ++ // Update context->uc_mcontext.regs to point to gp_regs ++ addi 0, 3, 0xe8 ++ std 0, 0xe0(3) ++ ++ // Save floating point registers 0-31 ++ stfd 0, 0x268(3) // context->uc_mcontext.fp_regs[0] ++ stfd 1, 0x270(3) // context->uc_mcontext.fp_regs[1] ++ stfd 2, 0x278(3) // context->uc_mcontext.fp_regs[2] ++ stfd 3, 0x280(3) // context->uc_mcontext.fp_regs[3] ++ stfd 4, 0x288(3) // context->uc_mcontext.fp_regs[4] ++ stfd 5, 0x290(3) // context->uc_mcontext.fp_regs[5] ++ stfd 6, 0x298(3) // context->uc_mcontext.fp_regs[6] ++ stfd 7, 0x2a0(3) // context->uc_mcontext.fp_regs[7] ++ stfd 8, 0x2a8(3) // context->uc_mcontext.fp_regs[8] ++ stfd 9, 0x2b0(3) // context->uc_mcontext.fp_regs[9] ++ stfd 10, 0x2b8(3) // context->uc_mcontext.fp_regs[10] ++ stfd 11, 0x2c0(3) // context->uc_mcontext.fp_regs[11] ++ stfd 12, 0x2c8(3) // context->uc_mcontext.fp_regs[12] ++ stfd 13, 0x2d0(3) // context->uc_mcontext.fp_regs[13] ++ stfd 14, 0x2d8(3) // context->uc_mcontext.fp_regs[14] ++ stfd 15, 0x2e0(3) // context->uc_mcontext.fp_regs[15] ++ stfd 16, 0x2e8(3) // context->uc_mcontext.fp_regs[16] ++ stfd 17, 0x2f0(3) // context->uc_mcontext.fp_regs[17] ++ stfd 18, 0x2f8(3) // context->uc_mcontext.fp_regs[18] ++ stfd 19, 0x300(3) // context->uc_mcontext.fp_regs[19] ++ stfd 20, 0x308(3) // context->uc_mcontext.fp_regs[20] ++ stfd 21, 0x310(3) // context->uc_mcontext.fp_regs[21] ++ stfd 22, 0x318(3) // context->uc_mcontext.fp_regs[22] ++ stfd 23, 0x320(3) // context->uc_mcontext.fp_regs[23] ++ stfd 24, 0x328(3) // context->uc_mcontext.fp_regs[24] ++ stfd 25, 0x330(3) // context->uc_mcontext.fp_regs[25] ++ stfd 26, 0x338(3) // context->uc_mcontext.fp_regs[26] ++ stfd 27, 0x340(3) // context->uc_mcontext.fp_regs[27] ++ stfd 28, 0x348(3) // context->uc_mcontext.fp_regs[28] ++ stfd 29, 0x350(3) // context->uc_mcontext.fp_regs[29] ++ stfd 30, 0x358(3) // context->uc_mcontext.fp_regs[30] ++ stfd 31, 0x360(3) // context->uc_mcontext.fp_regs[31] ++ ++ // FPSCR ++ mffs 0 ++ stfd 0, 0x368(3) // context->uc_mcontext.fp_regs[32] ++ ++ // Save VMX Vector registers ++ // Update r4 to contain the base address of vmx_reserve ++ addi 4, 3, 0x378 ++ // Ensure that it is quadword aligned ++ andi. 5, 4, 0xF ++ beq 1f // No alignment is necessary ++ // Address is doubleword aligned and not quadword aligned, add 8 ++ addi 4, 4, 8 ++ ++1: ++ // Store VMX registers 0-31 ++ // r4 will contain the base address ++ // r5 will contain the index ++ li 5, 0 ++ stvx 0, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 0] ++ addi 5, 5, 16 ++ stvx 1, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 1] ++ addi 5, 5, 16 ++ stvx 2, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 2] ++ addi 5, 5, 16 ++ stvx 3, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 3] ++ addi 5, 5, 16 ++ stvx 4, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 4] ++ addi 5, 5, 16 ++ stvx 5, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 5] ++ addi 5, 5, 16 ++ stvx 6, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 6] ++ addi 5, 5, 16 ++ stvx 7, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 7] ++ addi 5, 5, 16 ++ stvx 8, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 8] ++ addi 5, 5, 16 ++ stvx 9, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 9] ++ addi 5, 5, 16 ++ stvx 10, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 10] ++ addi 5, 5, 16 ++ stvx 11, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 11] ++ addi 5, 5, 16 ++ stvx 12, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 12] ++ addi 5, 5, 16 ++ stvx 13, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 13] ++ addi 5, 5, 16 ++ stvx 14, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 14] ++ addi 5, 5, 16 ++ stvx 15, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 15] ++ addi 5, 5, 16 ++ stvx 16, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 16] ++ addi 5, 5, 16 ++ stvx 17, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 17] ++ addi 5, 5, 16 ++ stvx 18, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 18] ++ addi 5, 5, 16 ++ stvx 19, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 19] ++ addi 5, 5, 16 ++ stvx 20, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 20] ++ addi 5, 5, 16 ++ stvx 21, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 21] ++ addi 5, 5, 16 ++ stvx 22, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 22] ++ addi 5, 5, 16 ++ stvx 23, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 23] ++ addi 5, 5, 16 ++ stvx 24, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 24] ++ addi 5, 5, 16 ++ stvx 25, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 25] ++ addi 5, 5, 16 ++ stvx 26, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 26] ++ addi 5, 5, 16 ++ stvx 27, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 27] ++ addi 5, 5, 16 ++ stvx 28, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 28] ++ addi 5, 5, 16 ++ stvx 29, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 29] ++ addi 5, 5, 16 ++ stvx 30, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 30] ++ addi 5, 5, 16 ++ stvx 31, 4, 5 // context->uc_mcontext.vmx_reserve[(align) + 31] ++ addi 5, 5, 16 ++ ++ // VSCR ++ mfvscr 0 ++ stvx 0, 4, 5 ++ addi 5, 5, 16 ++ ++ // VRSAVE ++ mfvrsave 0 ++ stwx 0, 4, 5 ++ ++ // Update context->uc_mcontext.v_regs to point to vmx_reserve + alignment. ++ std 4, 0x370(3) ++ ++ // Zero out all unused fields ++ li 4, 0 ++ std 4, 0xc8(3) // context->uc_mcontext.signal ++ std 4, 0xd0(3) // context->uc_mcontext.handler ++ std 4, 0xd8(3) // context->uc_mcontext.oldmask ++ ++ blr + #endif // __i386__ +diff --git a/chromium/third_party/crashpad/crashpad/util/misc/capture_context_test.cc b/chromium/third_party/crashpad/crashpad/util/misc/capture_context_test.cc +index 7137a313eb3..e0201803bfa 100644 +--- a/chromium/third_party/crashpad/crashpad/util/misc/capture_context_test.cc ++++ b/chromium/third_party/crashpad/crashpad/util/misc/capture_context_test.cc +@@ -49,7 +49,7 @@ void TestCaptureContext() { + // reference program counter. + uintptr_t pc = ProgramCounterFromContext(context_1); + +-#if !defined(ADDRESS_SANITIZER) && !defined(ARCH_CPU_MIPS_FAMILY) ++#if !defined(ADDRESS_SANITIZER) && !defined(ARCH_CPU_MIPS_FAMILY) && !defined(ARCH_CPU_PPC64_FAMILY) + // AddressSanitizer can cause enough code bloat that the “nearby” check would + // likely fail. + const uintptr_t kReferencePC = +diff --git a/chromium/third_party/crashpad/crashpad/util/misc/capture_context_test_util_linux.cc b/chromium/third_party/crashpad/crashpad/util/misc/capture_context_test_util_linux.cc +index 9fc5db28c48..5f69f8dcedb 100644 +--- a/chromium/third_party/crashpad/crashpad/util/misc/capture_context_test_util_linux.cc ++++ b/chromium/third_party/crashpad/crashpad/util/misc/capture_context_test_util_linux.cc +@@ -36,6 +36,8 @@ void SanityCheckContext(const NativeCPUContext& context) { + EXPECT_EQ(context.uc_mcontext.regs[0], FromPointerCast(&context)); + #elif defined(ARCH_CPU_MIPS_FAMILY) + EXPECT_EQ(context.uc_mcontext.gregs[4], FromPointerCast(&context)); ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ EXPECT_EQ(context.uc_mcontext.gp_regs[3], FromPointerCast(&context)); + #endif + } + +@@ -50,6 +52,8 @@ uintptr_t ProgramCounterFromContext(const NativeCPUContext& context) { + return context.uc_mcontext.pc; + #elif defined(ARCH_CPU_MIPS_FAMILY) + return context.uc_mcontext.pc; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ return context.uc_mcontext.gp_regs[PT_NIP]; + #endif + } + +@@ -64,6 +68,8 @@ uintptr_t StackPointerFromContext(const NativeCPUContext& context) { + return context.uc_mcontext.sp; + #elif defined(ARCH_CPU_MIPS_FAMILY) + return context.uc_mcontext.gregs[29]; ++#elif defined(ARCH_CPU_PPC64_FAMILY) ++ return context.uc_mcontext.gp_regs[1]; + #endif + } + +diff --git a/chromium/third_party/crashpad/crashpad/util/posix/signals_test.cc b/chromium/third_party/crashpad/crashpad/util/posix/signals_test.cc +index d91e3cc6622..b1ffc7b15ad 100644 +--- a/chromium/third_party/crashpad/crashpad/util/posix/signals_test.cc ++++ b/chromium/third_party/crashpad/crashpad/util/posix/signals_test.cc +@@ -46,12 +46,12 @@ bool CanCauseSignal(int sig) { + return sig == SIGABRT || + sig == SIGALRM || + sig == SIGBUS || +-#if !defined(ARCH_CPU_ARM64) ++#if !defined(ARCH_CPU_ARM64) && !defined(ARCH_CPU_PPC64) + sig == SIGFPE || +-#endif // !defined(ARCH_CPU_ARM64) ++#endif // !defined(ARCH_CPU_ARM64) && !defined(ARCH_CPU_PPC64) + #if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL) + sig == SIGILL || +-#endif // defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL ++#endif // defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL) + sig == SIGPIPE || + sig == SIGSEGV || + #if defined(OS_MACOSX) +@@ -117,9 +117,11 @@ void CauseSignal(int sig) { + break; + } + +-#if !defined(ARCH_CPU_ARM64) ++#if !defined(ARCH_CPU_ARM64) && !defined(ARCH_CPU_PPC64) + // ARM64 has hardware integer division instructions that don’t generate a + // trap for divide-by-zero, so this doesn’t produce SIGFPE. ++ // ++ // PPC64 fixed-point division by zero also doesn't produce a SIGFPE. + case SIGFPE: { + // Optimization makes this tricky, so get zero from a system call likely + // to succeed, and try to do something with the result. +@@ -137,7 +139,7 @@ void CauseSignal(int sig) { + fstat(quotient, &stat_buf); + break; + } +-#endif // ARCH_CPU_ARM64 ++#endif // !defined(ARCH_CPU_ARM64) && !defined(ARCH_CPU_PPC64) + + #if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL) + case SIGILL: { +-- +2.21.1 + + +From a57bfd90d1231a3953c18f24b9d5b47ab5d7a7df Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 14:01:38 +0100 +Subject: [PATCH 09/13] fix third_party/libvpx + +--- + chromium/third_party/libvpx/libvpx_srcs.gni | 358 ++++++++++++++++++++ + 1 file changed, 358 insertions(+) + +diff --git a/chromium/third_party/libvpx/libvpx_srcs.gni b/chromium/third_party/libvpx/libvpx_srcs.gni +index 1b76cc9bb4e..7ba350dfca4 100644 +--- a/chromium/third_party/libvpx/libvpx_srcs.gni ++++ b/chromium/third_party/libvpx/libvpx_srcs.gni +@@ -3754,6 +3754,364 @@ libvpx_srcs_mips = [ + "//third_party/libvpx/source/libvpx/vpx_util/vpx_write_yuv_frame.h", + ] + libvpx_srcs_mips_assembly = [] ++libvpx_srcs_ppc64 = [ ++ "//third_party/libvpx/source/libvpx/vp8/common/alloccommon.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/alloccommon.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/blockd.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/blockd.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/coefupdateprobs.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/common.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/copy_c.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/default_coef_probs.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/dequantize.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/entropy.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/entropy.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/entropymode.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/entropymode.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/entropymv.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/entropymv.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/extend.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/extend.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/filter.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/filter.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/findnearmv.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/findnearmv.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/generic/systemdependent.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/header.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/idct_blk.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/idctllm.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/invtrans.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/loopfilter.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/loopfilter_filters.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/mbpitch.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/mfqe.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/modecont.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/modecont.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/mv.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/onyx.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/onyxc_int.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/onyxd.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/postproc.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/postproc.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/ppflags.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/quant_common.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/quant_common.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/reconinter.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/reconinter.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/reconintra.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/reconintra.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/reconintra4x4.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/reconintra4x4.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/rtcd.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/setupintrarecon.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/setupintrarecon.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/swapyv12buffer.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/swapyv12buffer.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/systemdependent.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/threading.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/treecoder.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/treecoder.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/vp8_entropymodedata.h", ++ "//third_party/libvpx/source/libvpx/vp8/common/vp8_loopfilter.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/vp8_skin_detection.c", ++ "//third_party/libvpx/source/libvpx/vp8/common/vp8_skin_detection.h", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/dboolhuff.c", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/dboolhuff.h", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/decodeframe.c", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/decodemv.c", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/decodemv.h", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/decoderthreading.h", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/detokenize.c", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/detokenize.h", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/onyxd_if.c", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/onyxd_int.h", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/threading.c", ++ "//third_party/libvpx/source/libvpx/vp8/decoder/treereader.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/bitstream.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/bitstream.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/block.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/boolhuff.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/boolhuff.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/dct.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/dct_value_cost.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/dct_value_tokens.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/defaultcoefcounts.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/denoising.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/denoising.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/encodeframe.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/encodeframe.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/encodeintra.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/encodeintra.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/encodemb.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/encodemb.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/encodemv.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/encodemv.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/ethreading.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/ethreading.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/firstpass.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/lookahead.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/lookahead.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/mcomp.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/mcomp.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/modecosts.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/modecosts.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/mr_dissim.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/mr_dissim.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/onyx_if.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/onyx_int.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/pickinter.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/pickinter.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/picklpf.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/picklpf.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/quantize.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/ratectrl.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/ratectrl.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/rdopt.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/rdopt.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/segmentation.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/segmentation.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/tokenize.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/tokenize.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/treewriter.c", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/treewriter.h", ++ "//third_party/libvpx/source/libvpx/vp8/encoder/vp8_quantize.c", ++ "//third_party/libvpx/source/libvpx/vp8/vp8_cx_iface.c", ++ "//third_party/libvpx/source/libvpx/vp8/vp8_dx_iface.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/ppc/vp9_idct_vsx.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_alloccommon.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_alloccommon.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_blockd.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_blockd.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_common.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_common_data.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_common_data.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_entropy.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_entropy.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_entropymode.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_entropymode.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_entropymv.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_entropymv.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_enums.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_filter.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_filter.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_frame_buffers.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_frame_buffers.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_idct.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_idct.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_loopfilter.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_loopfilter.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_mfqe.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_mfqe.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_mv.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_mvref_common.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_mvref_common.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_onyxc_int.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_postproc.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_postproc.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_ppflags.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_pred_common.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_pred_common.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_quant_common.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_quant_common.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_reconinter.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_reconinter.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_reconintra.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_reconintra.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_rtcd.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_scale.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_scale.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_scan.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_scan.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_seg_common.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_seg_common.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_thread_common.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_thread_common.h", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_tile_common.c", ++ "//third_party/libvpx/source/libvpx/vp9/common/vp9_tile_common.h", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_decodeframe.c", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_decodeframe.h", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_decodemv.c", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_decodemv.h", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_decoder.c", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_decoder.h", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_detokenize.c", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_detokenize.h", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_dsubexp.c", ++ "//third_party/libvpx/source/libvpx/vp9/decoder/vp9_dsubexp.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/ppc/vp9_quantize_vsx.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_alt_ref_aq.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_alt_ref_aq.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_aq_360.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_aq_360.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_aq_complexity.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_aq_complexity.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_aq_cyclicrefresh.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_aq_cyclicrefresh.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_aq_variance.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_aq_variance.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_bitstream.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_bitstream.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_block.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_context_tree.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_context_tree.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_cost.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_cost.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_dct.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_denoiser.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_denoiser.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_encodeframe.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_encodeframe.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_encodemb.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_encodemb.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_encodemv.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_encodemv.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_encoder.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_encoder.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_ethread.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_ethread.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_extend.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_extend.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_firstpass.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_frame_scale.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_job_queue.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_lookahead.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_lookahead.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_mbgraph.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_mcomp.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_mcomp.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_multi_thread.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_multi_thread.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_noise_estimate.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_noise_estimate.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_picklpf.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_picklpf.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_pickmode.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_pickmode.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_quantize.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_quantize.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_ratectrl.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_ratectrl.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_rd.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_rd.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_rdopt.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_rdopt.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_resize.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_resize.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_segmentation.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_segmentation.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_skin_detection.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_skin_detection.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_speed_features.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_speed_features.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_subexp.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_subexp.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_svc_layercontext.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_svc_layercontext.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_temporal_filter.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_tokenize.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_tokenize.h", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_treewriter.c", ++ "//third_party/libvpx/source/libvpx/vp9/encoder/vp9_treewriter.h", ++ "//third_party/libvpx/source/libvpx/vp9/vp9_cx_iface.c", ++ "//third_party/libvpx/source/libvpx/vp9/vp9_dx_iface.c", ++ "//third_party/libvpx/source/libvpx/vp9/vp9_dx_iface.h", ++ "//third_party/libvpx/source/libvpx/vp9/vp9_iface_common.h", ++ "//third_party/libvpx/source/libvpx/vpx/internal/vpx_codec_internal.h", ++ "//third_party/libvpx/source/libvpx/vpx/src/svc_encodeframe.c", ++ "//third_party/libvpx/source/libvpx/vpx/src/vpx_codec.c", ++ "//third_party/libvpx/source/libvpx/vpx/src/vpx_decoder.c", ++ "//third_party/libvpx/source/libvpx/vpx/src/vpx_encoder.c", ++ "//third_party/libvpx/source/libvpx/vpx/src/vpx_image.c", ++ "//third_party/libvpx/source/libvpx/vpx/svc_context.h", ++ "//third_party/libvpx/source/libvpx/vpx/vp8.h", ++ "//third_party/libvpx/source/libvpx/vpx/vp8cx.h", ++ "//third_party/libvpx/source/libvpx/vpx/vp8dx.h", ++ "//third_party/libvpx/source/libvpx/vpx/vpx_codec.h", ++ "//third_party/libvpx/source/libvpx/vpx/vpx_decoder.h", ++ "//third_party/libvpx/source/libvpx/vpx/vpx_encoder.h", ++ "//third_party/libvpx/source/libvpx/vpx/vpx_frame_buffer.h", ++ "//third_party/libvpx/source/libvpx/vpx/vpx_image.h", ++ "//third_party/libvpx/source/libvpx/vpx/vpx_integer.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/add_noise.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/avg.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/bitreader.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/bitreader.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/bitreader_buffer.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/bitreader_buffer.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/bitwriter.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/bitwriter.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/bitwriter_buffer.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/bitwriter_buffer.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/deblock.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/fwd_txfm.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/fwd_txfm.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/intrapred.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/inv_txfm.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/inv_txfm.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/loopfilter.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/postproc.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/bitdepth_conversion_vsx.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/deblock_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/fdct32x32_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/hadamard_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/intrapred_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/inv_txfm_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/quantize_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/sad_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/subtract_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/transpose_vsx.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/txfm_common_vsx.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/types_vsx.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/variance_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/ppc/vpx_convolve_vsx.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/prob.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/prob.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/psnr.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/psnr.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/quantize.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/quantize.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/sad.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/skin_detection.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/skin_detection.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/subtract.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/sum_squares.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/txfm_common.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/variance.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/variance.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/vpx_convolve.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/vpx_convolve.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/vpx_dsp_common.h", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/vpx_dsp_rtcd.c", ++ "//third_party/libvpx/source/libvpx/vpx_dsp/vpx_filter.h", ++ "//third_party/libvpx/source/libvpx/vpx_mem/include/vpx_mem_intrnl.h", ++ "//third_party/libvpx/source/libvpx/vpx_mem/vpx_mem.c", ++ "//third_party/libvpx/source/libvpx/vpx_mem/vpx_mem.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/bitops.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/emmintrin_compat.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/mem.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/mem_ops.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/mem_ops_aligned.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/msvc.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/ppc.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/ppc_cpudetect.c", ++ "//third_party/libvpx/source/libvpx/vpx_ports/system_state.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/vpx_once.h", ++ "//third_party/libvpx/source/libvpx/vpx_ports/vpx_timer.h", ++ "//third_party/libvpx/source/libvpx/vpx_scale/generic/gen_scalers.c", ++ "//third_party/libvpx/source/libvpx/vpx_scale/generic/vpx_scale.c", ++ "//third_party/libvpx/source/libvpx/vpx_scale/generic/yv12config.c", ++ "//third_party/libvpx/source/libvpx/vpx_scale/generic/yv12extend.c", ++ "//third_party/libvpx/source/libvpx/vpx_scale/vpx_scale.h", ++ "//third_party/libvpx/source/libvpx/vpx_scale/vpx_scale_rtcd.c", ++ "//third_party/libvpx/source/libvpx/vpx_scale/yv12config.h", ++ "//third_party/libvpx/source/libvpx/vpx_util/endian_inl.h", ++ "//third_party/libvpx/source/libvpx/vpx_util/vpx_atomics.h", ++ "//third_party/libvpx/source/libvpx/vpx_util/vpx_thread.c", ++ "//third_party/libvpx/source/libvpx/vpx_util/vpx_thread.h", ++ "//third_party/libvpx/source/libvpx/vpx_util/vpx_write_yuv_frame.c", ++ "//third_party/libvpx/source/libvpx/vpx_util/vpx_write_yuv_frame.h", ++] ++libvpx_srcs_ppc64_assembly = [] + libvpx_srcs_nacl = [ + "//third_party/libvpx/source/libvpx/vp8/common/alloccommon.c", + "//third_party/libvpx/source/libvpx/vp8/common/alloccommon.h", +-- +2.21.1 + + +From 08a8f7f794c7e3158d5bfadc358b32906c63be04 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 14:04:42 +0100 +Subject: [PATCH 10/13] fix third_party/blink + +--- + chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h b/chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h +index 19a222edfd0..2dfc5a4f47b 100644 +--- a/chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h ++++ b/chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h +@@ -45,7 +45,7 @@ + // disabled.) + // On Linux,x86 89255e-22 != Div_double(89255.0/1e22) + #if defined(_M_X64) || defined(__x86_64__) || defined(__ARMEL__) || \ +- defined(__aarch64__) || defined(__MIPSEL__) ++ defined(__aarch64__) || defined(__MIPSEL__) || defined(__powerpc64__) + #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 + #elif defined(_M_IX86) || defined(__i386__) + #if defined(_WIN32) +-- +2.21.1 + + +From ccf3ef182a070536027efa73f9408f79a82b8942 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 14:10:32 +0100 +Subject: [PATCH 11/13] update third_party/pdfium for ppc64 + +--- + .../partition_allocator/page_allocator_constants.h | 6 +++++- + .../partition_allocator/partition_alloc_constants.h | 2 ++ + 2 files changed, 7 insertions(+), 1 deletion(-) + +diff --git a/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/page_allocator_constants.h b/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/page_allocator_constants.h +index 945273b1f25..e1735f2e5eb 100644 +--- a/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/page_allocator_constants.h ++++ b/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/page_allocator_constants.h +@@ -11,7 +11,7 @@ + + namespace pdfium { + namespace base { +-#if defined(OS_WIN) ++#if defined(OS_WIN) || defined(ARCH_CPU_PPC64) + static constexpr size_t kPageAllocationGranularityShift = 16; // 64KB + #elif defined(_MIPS_ARCH_LOONGSON) + static constexpr size_t kPageAllocationGranularityShift = 14; // 16KB +@@ -27,6 +27,10 @@ static constexpr size_t kPageAllocationGranularityBaseMask = + + #if defined(_MIPS_ARCH_LOONGSON) + static constexpr size_t kSystemPageSize = 16384; ++#elif defined(ARCH_CPU_PPC64) ++// TODO: modern ppc64 can do 4k and 64k page sizes ++// for now, 64k is assumed ++static constexpr size_t kSystemPageSize = 65536; + #else + static constexpr size_t kSystemPageSize = 4096; + #endif +diff --git a/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/partition_alloc_constants.h b/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/partition_alloc_constants.h +index cd9108cec2b..4febb7a2b4c 100644 +--- a/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/partition_alloc_constants.h ++++ b/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/partition_alloc_constants.h +@@ -33,6 +33,8 @@ static const size_t kBucketShift = (kAllocationGranularity == 8) ? 3 : 2; + // up against the end of a system page. + #if defined(_MIPS_ARCH_LOONGSON) + static const size_t kPartitionPageShift = 16; // 64KB ++#elif defined(ARCH_CPU_PPC64) ++static const size_t kPartitionPageShift = 18; // 256 KiB + #else + static const size_t kPartitionPageShift = 14; // 16KB + #endif +-- +2.21.1 + + +From d496a48b5087f35d9983b615791c85590abeaa93 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 17:44:09 +0100 +Subject: [PATCH 12/13] update third_party/ffpmeg for ppc64 + +--- + .../config/Chrome/linux/ppc64/config.h | 2478 +++++++++++++++++ + .../Chrome/linux/ppc64/libavcodec/bsf_list.c | 3 + + .../linux/ppc64/libavcodec/codec_list.c | 20 + + .../linux/ppc64/libavcodec/parser_list.c | 10 + + .../linux/ppc64/libavformat/demuxer_list.c | 9 + + .../linux/ppc64/libavformat/muxer_list.c | 2 + + .../linux/ppc64/libavformat/protocol_list.c | 2 + + .../Chrome/linux/ppc64/libavutil/avconfig.h | 6 + + .../Chrome/linux/ppc64/libavutil/ffversion.h | 5 + + .../config/ChromeOS/linux/ppc64/config.h | 2478 +++++++++++++++++ + .../linux/ppc64/libavcodec/bsf_list.c | 3 + + .../linux/ppc64/libavcodec/codec_list.c | 25 + + .../linux/ppc64/libavcodec/parser_list.c | 13 + + .../linux/ppc64/libavformat/demuxer_list.c | 11 + + .../linux/ppc64/libavformat/muxer_list.c | 2 + + .../linux/ppc64/libavformat/protocol_list.c | 2 + + .../ChromeOS/linux/ppc64/libavutil/avconfig.h | 6 + + .../linux/ppc64/libavutil/ffversion.h | 5 + + .../config/Chromium/linux/ppc64/config.h | 2478 +++++++++++++++++ + .../linux/ppc64/libavcodec/bsf_list.c | 3 + + .../linux/ppc64/libavcodec/codec_list.c | 18 + + .../linux/ppc64/libavcodec/parser_list.c | 8 + + .../linux/ppc64/libavformat/demuxer_list.c | 8 + + .../linux/ppc64/libavformat/muxer_list.c | 2 + + .../linux/ppc64/libavformat/protocol_list.c | 2 + + .../Chromium/linux/ppc64/libavutil/avconfig.h | 6 + + .../linux/ppc64/libavutil/ffversion.h | 5 + + .../ffmpeg/chromium/scripts/build_ffmpeg.py | 11 +- + .../ffmpeg/chromium/scripts/copy_config.sh | 2 +- + .../ffmpeg/chromium/scripts/generate_gn.py | 2 +- + .../chromium/scripts/generate_gn_unittest.py | 10 +- + .../ffmpeg/ffmpeg_generated.gni.ppc64 | 319 +++ + .../autorename_libavcodec_fdctdsp.c | 2 + + .../autorename_libavcodec_h264dsp.c | 2 + + .../autorename_libavcodec_h264qpel.c | 2 + + .../ppc/autorename_libavcodec_ppc_idctdsp.c | 2 + + .../ppc/autorename_libavcodec_ppc_me_cmp.c | 2 + + .../ppc/autorename_libavutil_ppc_cpu.c | 2 + + 38 files changed, 7960 insertions(+), 6 deletions(-) + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/config.h + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/bsf_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/codec_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/parser_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/demuxer_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/muxer_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/protocol_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavutil/avconfig.h + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavutil/ffversion.h + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/config.h + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/bsf_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/codec_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/parser_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/demuxer_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/muxer_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/protocol_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavutil/avconfig.h + create mode 100644 chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavutil/ffversion.h + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/config.h + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/bsf_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/codec_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/parser_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/demuxer_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/muxer_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/protocol_list.c + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavutil/avconfig.h + create mode 100644 chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavutil/ffversion.h + create mode 100644 chromium/third_party/ffmpeg/ffmpeg_generated.gni.ppc64 + create mode 100644 chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_fdctdsp.c + create mode 100644 chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_h264dsp.c + create mode 100644 chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_h264qpel.c + create mode 100644 chromium/third_party/ffmpeg/libavcodec/ppc/autorename_libavcodec_ppc_idctdsp.c + create mode 100644 chromium/third_party/ffmpeg/libavcodec/ppc/autorename_libavcodec_ppc_me_cmp.c + create mode 100644 chromium/third_party/ffmpeg/libavutil/ppc/autorename_libavutil_ppc_cpu.c + +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/config.h b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/config.h +new file mode 100644 +index 00000000000..c4cd398fd09 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/config.h +@@ -0,0 +1,2478 @@ ++/* Automatically generated by configure - do not modify! */ ++#ifndef FFMPEG_CONFIG_H ++#define FFMPEG_CONFIG_H ++/* #define FFMPEG_CONFIGURATION "--disable-everything --disable-all --disable-doc --disable-htmlpages --disable-manpages --disable-podpages --disable-txtpages --disable-static --enable-avcodec --enable-avformat --enable-avutil --enable-fft --enable-rdft --enable-static --enable-libopus --disable-debug --disable-bzlib --disable-error-resilience --disable-iconv --disable-lzo --disable-network --disable-schannel --disable-sdl2 --disable-symver --disable-xlib --disable-zlib --disable-securetransport --disable-faan --disable-alsa --disable-autodetect --enable-decoder='vorbis,libopus,flac' --enable-decoder='pcm_u8,pcm_s16le,pcm_s24le,pcm_s32le,pcm_f32le,mp3' --enable-decoder='pcm_s16be,pcm_s24be,pcm_mulaw,pcm_alaw' --enable-demuxer='ogg,matroska,wav,flac,mp3,mov' --enable-parser='opus,vorbis,flac,mpegaudio' --extra-cflags=-I/mnt/dan/qtwebengine/src/3rdparty/chromium/third_party/opus/src/include --disable-linux-perf --x86asmexe=nasm --optflags='\"-O2\"' --enable-decoder='theora,vp8' --enable-parser='vp3,vp8' --arch=ppc64le --extra-cflags='-mcpu=power9' --enable-pic --cc=clang --cxx=clang++ --ld=clang --enable-decoder='aac,h264' --enable-demuxer=aac --enable-parser='aac,h264'" -- elide long configuration string from binary */ ++#define FFMPEG_LICENSE "LGPL version 2.1 or later" ++#define CONFIG_THIS_YEAR 2018 ++#define FFMPEG_DATADIR "/usr/local/share/ffmpeg" ++#define AVCONV_DATADIR "/usr/local/share/ffmpeg" ++#define CC_IDENT "clang version 8.0.0 (Fedora 8.0.0-3.fc30)" ++#define av_restrict restrict ++#define EXTERN_PREFIX "" ++#define EXTERN_ASM ++#define BUILDSUF "" ++#define SLIBSUF ".so" ++#define HAVE_MMX2 HAVE_MMXEXT ++#define SWS_MAX_FILTER_SIZE 256 ++#define ARCH_AARCH64 0 ++#define ARCH_ALPHA 0 ++#define ARCH_ARM 0 ++#define ARCH_AVR32 0 ++#define ARCH_AVR32_AP 0 ++#define ARCH_AVR32_UC 0 ++#define ARCH_BFIN 0 ++#define ARCH_IA64 0 ++#define ARCH_M68K 0 ++#define ARCH_MIPS 0 ++#define ARCH_MIPS64 0 ++#define ARCH_PARISC 0 ++#define ARCH_PPC 1 ++#define ARCH_PPC64 1 ++#define ARCH_S390 0 ++#define ARCH_SH4 0 ++#define ARCH_SPARC 0 ++#define ARCH_SPARC64 0 ++#define ARCH_TILEGX 0 ++#define ARCH_TILEPRO 0 ++#define ARCH_TOMI 0 ++#define ARCH_X86 0 ++#define ARCH_X86_32 0 ++#define ARCH_X86_64 0 ++#define HAVE_ARMV5TE 0 ++#define HAVE_ARMV6 0 ++#define HAVE_ARMV6T2 0 ++#define HAVE_ARMV8 0 ++#define HAVE_NEON 0 ++#define HAVE_VFP 0 ++#define HAVE_VFPV3 0 ++#define HAVE_SETEND 0 ++#define HAVE_ALTIVEC 1 ++#define HAVE_DCBZL 1 ++#define HAVE_LDBRX 0 ++#define HAVE_POWER8 1 ++#define HAVE_PPC4XX 0 ++#define HAVE_VSX 1 ++#define HAVE_AESNI 0 ++#define HAVE_AMD3DNOW 0 ++#define HAVE_AMD3DNOWEXT 0 ++#define HAVE_AVX 0 ++#define HAVE_AVX2 0 ++#define HAVE_AVX512 0 ++#define HAVE_FMA3 0 ++#define HAVE_FMA4 0 ++#define HAVE_MMX 0 ++#define HAVE_MMXEXT 0 ++#define HAVE_SSE 0 ++#define HAVE_SSE2 0 ++#define HAVE_SSE3 0 ++#define HAVE_SSE4 0 ++#define HAVE_SSE42 0 ++#define HAVE_SSSE3 0 ++#define HAVE_XOP 0 ++#define HAVE_CPUNOP 0 ++#define HAVE_I686 0 ++#define HAVE_MIPSFPU 0 ++#define HAVE_MIPS32R2 0 ++#define HAVE_MIPS32R5 0 ++#define HAVE_MIPS64R2 0 ++#define HAVE_MIPS32R6 0 ++#define HAVE_MIPS64R6 0 ++#define HAVE_MIPSDSP 0 ++#define HAVE_MIPSDSPR2 0 ++#define HAVE_MSA 0 ++#define HAVE_LOONGSON2 0 ++#define HAVE_LOONGSON3 0 ++#define HAVE_MMI 0 ++#define HAVE_ARMV5TE_EXTERNAL 0 ++#define HAVE_ARMV6_EXTERNAL 0 ++#define HAVE_ARMV6T2_EXTERNAL 0 ++#define HAVE_ARMV8_EXTERNAL 0 ++#define HAVE_NEON_EXTERNAL 0 ++#define HAVE_VFP_EXTERNAL 0 ++#define HAVE_VFPV3_EXTERNAL 0 ++#define HAVE_SETEND_EXTERNAL 0 ++#define HAVE_ALTIVEC_EXTERNAL 0 ++#define HAVE_DCBZL_EXTERNAL 0 ++#define HAVE_LDBRX_EXTERNAL 0 ++#define HAVE_POWER8_EXTERNAL 0 ++#define HAVE_PPC4XX_EXTERNAL 0 ++#define HAVE_VSX_EXTERNAL 0 ++#define HAVE_AESNI_EXTERNAL 0 ++#define HAVE_AMD3DNOW_EXTERNAL 0 ++#define HAVE_AMD3DNOWEXT_EXTERNAL 0 ++#define HAVE_AVX_EXTERNAL 0 ++#define HAVE_AVX2_EXTERNAL 0 ++#define HAVE_AVX512_EXTERNAL 0 ++#define HAVE_FMA3_EXTERNAL 0 ++#define HAVE_FMA4_EXTERNAL 0 ++#define HAVE_MMX_EXTERNAL 0 ++#define HAVE_MMXEXT_EXTERNAL 0 ++#define HAVE_SSE_EXTERNAL 0 ++#define HAVE_SSE2_EXTERNAL 0 ++#define HAVE_SSE3_EXTERNAL 0 ++#define HAVE_SSE4_EXTERNAL 0 ++#define HAVE_SSE42_EXTERNAL 0 ++#define HAVE_SSSE3_EXTERNAL 0 ++#define HAVE_XOP_EXTERNAL 0 ++#define HAVE_CPUNOP_EXTERNAL 0 ++#define HAVE_I686_EXTERNAL 0 ++#define HAVE_MIPSFPU_EXTERNAL 0 ++#define HAVE_MIPS32R2_EXTERNAL 0 ++#define HAVE_MIPS32R5_EXTERNAL 0 ++#define HAVE_MIPS64R2_EXTERNAL 0 ++#define HAVE_MIPS32R6_EXTERNAL 0 ++#define HAVE_MIPS64R6_EXTERNAL 0 ++#define HAVE_MIPSDSP_EXTERNAL 0 ++#define HAVE_MIPSDSPR2_EXTERNAL 0 ++#define HAVE_MSA_EXTERNAL 0 ++#define HAVE_LOONGSON2_EXTERNAL 0 ++#define HAVE_LOONGSON3_EXTERNAL 0 ++#define HAVE_MMI_EXTERNAL 0 ++#define HAVE_ARMV5TE_INLINE 0 ++#define HAVE_ARMV6_INLINE 0 ++#define HAVE_ARMV6T2_INLINE 0 ++#define HAVE_ARMV8_INLINE 0 ++#define HAVE_NEON_INLINE 0 ++#define HAVE_VFP_INLINE 0 ++#define HAVE_VFPV3_INLINE 0 ++#define HAVE_SETEND_INLINE 0 ++#define HAVE_ALTIVEC_INLINE 0 ++#define HAVE_DCBZL_INLINE 0 ++#define HAVE_LDBRX_INLINE 0 ++#define HAVE_POWER8_INLINE 0 ++#define HAVE_PPC4XX_INLINE 0 ++#define HAVE_VSX_INLINE 0 ++#define HAVE_AESNI_INLINE 0 ++#define HAVE_AMD3DNOW_INLINE 0 ++#define HAVE_AMD3DNOWEXT_INLINE 0 ++#define HAVE_AVX_INLINE 0 ++#define HAVE_AVX2_INLINE 0 ++#define HAVE_AVX512_INLINE 0 ++#define HAVE_FMA3_INLINE 0 ++#define HAVE_FMA4_INLINE 0 ++#define HAVE_MMX_INLINE 0 ++#define HAVE_MMXEXT_INLINE 0 ++#define HAVE_SSE_INLINE 0 ++#define HAVE_SSE2_INLINE 0 ++#define HAVE_SSE3_INLINE 0 ++#define HAVE_SSE4_INLINE 0 ++#define HAVE_SSE42_INLINE 0 ++#define HAVE_SSSE3_INLINE 0 ++#define HAVE_XOP_INLINE 0 ++#define HAVE_CPUNOP_INLINE 0 ++#define HAVE_I686_INLINE 0 ++#define HAVE_MIPSFPU_INLINE 0 ++#define HAVE_MIPS32R2_INLINE 0 ++#define HAVE_MIPS32R5_INLINE 0 ++#define HAVE_MIPS64R2_INLINE 0 ++#define HAVE_MIPS32R6_INLINE 0 ++#define HAVE_MIPS64R6_INLINE 0 ++#define HAVE_MIPSDSP_INLINE 0 ++#define HAVE_MIPSDSPR2_INLINE 0 ++#define HAVE_MSA_INLINE 0 ++#define HAVE_LOONGSON2_INLINE 0 ++#define HAVE_LOONGSON3_INLINE 0 ++#define HAVE_MMI_INLINE 0 ++#define HAVE_ALIGNED_STACK 1 ++#define HAVE_FAST_64BIT 1 ++#define HAVE_FAST_CLZ 1 ++#define HAVE_FAST_CMOV 0 ++#define HAVE_LOCAL_ALIGNED 1 ++#define HAVE_SIMD_ALIGN_16 1 ++#define HAVE_SIMD_ALIGN_32 0 ++#define HAVE_SIMD_ALIGN_64 0 ++#define HAVE_ATOMIC_CAS_PTR 0 ++#define HAVE_MACHINE_RW_BARRIER 0 ++#define HAVE_MEMORYBARRIER 0 ++#define HAVE_MM_EMPTY 0 ++#define HAVE_RDTSC 0 ++#define HAVE_SEM_TIMEDWAIT 1 ++#define HAVE_SYNC_VAL_COMPARE_AND_SWAP 1 ++#define HAVE_CABS 0 ++#define HAVE_CEXP 0 ++#define HAVE_INLINE_ASM 1 ++#define HAVE_SYMVER 0 ++#define HAVE_X86ASM 0 ++#define HAVE_BIGENDIAN 0 ++#define HAVE_FAST_UNALIGNED 1 ++#define HAVE_ARPA_INET_H 0 ++#define HAVE_ASM_TYPES_H 1 ++#define HAVE_CDIO_PARANOIA_H 0 ++#define HAVE_CDIO_PARANOIA_PARANOIA_H 0 ++#define HAVE_CUDA_H 0 ++#define HAVE_DISPATCH_DISPATCH_H 0 ++#define HAVE_DEV_BKTR_IOCTL_BT848_H 0 ++#define HAVE_DEV_BKTR_IOCTL_METEOR_H 0 ++#define HAVE_DEV_IC_BT8XX_H 0 ++#define HAVE_DEV_VIDEO_BKTR_IOCTL_BT848_H 0 ++#define HAVE_DEV_VIDEO_METEOR_IOCTL_METEOR_H 0 ++#define HAVE_DIRECT_H 0 ++#define HAVE_DIRENT_H 1 ++#define HAVE_DXGIDEBUG_H 0 ++#define HAVE_DXVA_H 0 ++#define HAVE_ES2_GL_H 0 ++#define HAVE_GSM_H 0 ++#define HAVE_IO_H 0 ++#define HAVE_LINUX_PERF_EVENT_H 1 ++#define HAVE_MACHINE_IOCTL_BT848_H 0 ++#define HAVE_MACHINE_IOCTL_METEOR_H 0 ++#define HAVE_MALLOC_H 1 ++#define HAVE_OPENCV2_CORE_CORE_C_H 0 ++#define HAVE_OPENGL_GL3_H 0 ++#define HAVE_POLL_H 1 ++#define HAVE_SYS_PARAM_H 1 ++#define HAVE_SYS_RESOURCE_H 1 ++#define HAVE_SYS_SELECT_H 1 ++#define HAVE_SYS_SOUNDCARD_H 1 ++#define HAVE_SYS_TIME_H 1 ++#define HAVE_SYS_UN_H 1 ++#define HAVE_SYS_VIDEOIO_H 0 ++#define HAVE_TERMIOS_H 1 ++#define HAVE_UDPLITE_H 0 ++#define HAVE_UNISTD_H 1 ++#define HAVE_VALGRIND_VALGRIND_H 0 /* #define HAVE_VALGRIND_VALGRIND_H 1 -- forced to 0. See https://crbug.com/590440 */ ++#define HAVE_WINDOWS_H 0 ++#define HAVE_WINSOCK2_H 0 ++#define HAVE_INTRINSICS_NEON 0 ++#define HAVE_ATANF 1 ++#define HAVE_ATAN2F 1 ++#define HAVE_CBRT 1 ++#define HAVE_CBRTF 1 ++#define HAVE_COPYSIGN 1 ++#define HAVE_COSF 1 ++#define HAVE_ERF 1 ++#define HAVE_EXP2 1 ++#define HAVE_EXP2F 1 ++#define HAVE_EXPF 1 ++#define HAVE_HYPOT 1 ++#define HAVE_ISFINITE 1 ++#define HAVE_ISINF 1 ++#define HAVE_ISNAN 1 ++#define HAVE_LDEXPF 1 ++#define HAVE_LLRINT 1 ++#define HAVE_LLRINTF 1 ++#define HAVE_LOG2 1 ++#define HAVE_LOG2F 1 ++#define HAVE_LOG10F 1 ++#define HAVE_LRINT 1 ++#define HAVE_LRINTF 1 ++#define HAVE_POWF 1 ++#define HAVE_RINT 1 ++#define HAVE_ROUND 1 ++#define HAVE_ROUNDF 1 ++#define HAVE_SINF 1 ++#define HAVE_TRUNC 1 ++#define HAVE_TRUNCF 1 ++#define HAVE_DOS_PATHS 0 ++#define HAVE_LIBC_MSVCRT 0 ++#define HAVE_MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS 0 ++#define HAVE_SECTION_DATA_REL_RO 1 ++#define HAVE_THREADS 1 ++#define HAVE_UWP 0 ++#define HAVE_WINRT 0 ++#define HAVE_ACCESS 1 ++#define HAVE_ALIGNED_MALLOC 0 ++#define HAVE_ARC4RANDOM 0 ++#define HAVE_CLOCK_GETTIME 1 ++#define HAVE_CLOSESOCKET 0 ++#define HAVE_COMMANDLINETOARGVW 0 ++#define HAVE_FCNTL 1 ++#define HAVE_GETADDRINFO 0 ++#define HAVE_GETHRTIME 0 ++#define HAVE_GETOPT 1 ++#define HAVE_GETPROCESSAFFINITYMASK 0 ++#define HAVE_GETPROCESSMEMORYINFO 0 ++#define HAVE_GETPROCESSTIMES 0 ++#define HAVE_GETRUSAGE 1 ++#define HAVE_GETSYSTEMTIMEASFILETIME 0 ++#define HAVE_GETTIMEOFDAY 1 ++#define HAVE_GLOB 1 ++#define HAVE_GLXGETPROCADDRESS 0 ++#define HAVE_GMTIME_R 1 ++#define HAVE_INET_ATON 0 ++#define HAVE_ISATTY 1 ++#define HAVE_KBHIT 0 ++#define HAVE_LOCALTIME_R 1 ++#define HAVE_LSTAT 1 ++#define HAVE_LZO1X_999_COMPRESS 0 ++#define HAVE_MACH_ABSOLUTE_TIME 0 ++#define HAVE_MAPVIEWOFFILE 0 ++#define HAVE_MEMALIGN 1 ++#define HAVE_MKSTEMP 1 ++#define HAVE_MMAP 1 ++#define HAVE_MPROTECT 1 ++#define HAVE_NANOSLEEP 1 ++#define HAVE_PEEKNAMEDPIPE 0 ++#define HAVE_POSIX_MEMALIGN 1 ++#define HAVE_PTHREAD_CANCEL 1 ++#define HAVE_SCHED_GETAFFINITY 1 ++#define HAVE_SECITEMIMPORT 0 ++#define HAVE_SETCONSOLETEXTATTRIBUTE 0 ++#define HAVE_SETCONSOLECTRLHANDLER 0 ++#define HAVE_SETMODE 0 ++#define HAVE_SETRLIMIT 1 ++#define HAVE_SLEEP 0 ++#define HAVE_STRERROR_R 1 ++#define HAVE_SYSCONF 1 ++#define HAVE_SYSCTL 0 /* #define HAVE_SYSCTL 1 -- forced to 0 for Fuchsia */ ++#define HAVE_USLEEP 1 ++#define HAVE_UTGETOSTYPEFROMSTRING 0 ++#define HAVE_VIRTUALALLOC 0 ++#define HAVE_WGLGETPROCADDRESS 0 ++#define HAVE_BCRYPT 0 ++#define HAVE_VAAPI_DRM 0 ++#define HAVE_VAAPI_X11 0 ++#define HAVE_VDPAU_X11 0 ++#define HAVE_PTHREADS 1 ++#define HAVE_OS2THREADS 0 ++#define HAVE_W32THREADS 0 ++#define HAVE_AS_ARCH_DIRECTIVE 0 ++#define HAVE_AS_DN_DIRECTIVE 0 ++#define HAVE_AS_FPU_DIRECTIVE 0 ++#define HAVE_AS_FUNC 0 ++#define HAVE_AS_OBJECT_ARCH 0 ++#define HAVE_ASM_MOD_Q 0 ++#define HAVE_BLOCKS_EXTENSION 0 ++#define HAVE_EBP_AVAILABLE 0 ++#define HAVE_EBX_AVAILABLE 0 ++#define HAVE_GNU_AS 0 ++#define HAVE_GNU_WINDRES 0 ++#define HAVE_IBM_ASM 1 ++#define HAVE_INLINE_ASM_DIRECT_SYMBOL_REFS 0 ++#define HAVE_INLINE_ASM_LABELS 1 ++#define HAVE_INLINE_ASM_NONLOCAL_LABELS 1 ++#define HAVE_PRAGMA_DEPRECATED 1 ++#define HAVE_RSYNC_CONTIMEOUT 1 ++#define HAVE_SYMVER_ASM_LABEL 1 ++#define HAVE_SYMVER_GNU_ASM 1 ++#define HAVE_VFP_ARGS 0 ++#define HAVE_XFORM_ASM 1 ++#define HAVE_XMM_CLOBBERS 0 ++#define HAVE_KCMVIDEOCODECTYPE_HEVC 0 ++#define HAVE_SOCKLEN_T 0 ++#define HAVE_STRUCT_ADDRINFO 0 ++#define HAVE_STRUCT_GROUP_SOURCE_REQ 0 ++#define HAVE_STRUCT_IP_MREQ_SOURCE 0 ++#define HAVE_STRUCT_IPV6_MREQ 0 ++#define HAVE_STRUCT_MSGHDR_MSG_FLAGS 0 ++#define HAVE_STRUCT_POLLFD 0 ++#define HAVE_STRUCT_RUSAGE_RU_MAXRSS 1 ++#define HAVE_STRUCT_SCTP_EVENT_SUBSCRIBE 0 ++#define HAVE_STRUCT_SOCKADDR_IN6 0 ++#define HAVE_STRUCT_SOCKADDR_SA_LEN 0 ++#define HAVE_STRUCT_SOCKADDR_STORAGE 0 ++#define HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 1 ++#define HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE 0 ++#define HAVE_MAKEINFO 1 ++#define HAVE_MAKEINFO_HTML 1 ++#define HAVE_OPENCL_D3D11 0 ++#define HAVE_OPENCL_DRM_ARM 0 ++#define HAVE_OPENCL_DRM_BEIGNET 0 ++#define HAVE_OPENCL_DXVA2 0 ++#define HAVE_OPENCL_VAAPI_BEIGNET 0 ++#define HAVE_OPENCL_VAAPI_INTEL_MEDIA 0 ++#define HAVE_PERL 1 ++#define HAVE_POD2MAN 1 ++#define HAVE_TEXI2HTML 0 ++#define CONFIG_DOC 0 ++#define CONFIG_HTMLPAGES 0 ++#define CONFIG_MANPAGES 0 ++#define CONFIG_PODPAGES 0 ++#define CONFIG_TXTPAGES 0 ++#define CONFIG_AVIO_DIR_CMD_EXAMPLE 1 ++#define CONFIG_AVIO_READING_EXAMPLE 1 ++#define CONFIG_DECODE_AUDIO_EXAMPLE 1 ++#define CONFIG_DECODE_VIDEO_EXAMPLE 1 ++#define CONFIG_DEMUXING_DECODING_EXAMPLE 1 ++#define CONFIG_ENCODE_AUDIO_EXAMPLE 1 ++#define CONFIG_ENCODE_VIDEO_EXAMPLE 1 ++#define CONFIG_EXTRACT_MVS_EXAMPLE 1 ++#define CONFIG_FILTER_AUDIO_EXAMPLE 0 ++#define CONFIG_FILTERING_AUDIO_EXAMPLE 0 ++#define CONFIG_FILTERING_VIDEO_EXAMPLE 0 ++#define CONFIG_HTTP_MULTICLIENT_EXAMPLE 1 ++#define CONFIG_HW_DECODE_EXAMPLE 1 ++#define CONFIG_METADATA_EXAMPLE 1 ++#define CONFIG_MUXING_EXAMPLE 0 ++#define CONFIG_QSVDEC_EXAMPLE 0 ++#define CONFIG_REMUXING_EXAMPLE 1 ++#define CONFIG_RESAMPLING_AUDIO_EXAMPLE 0 ++#define CONFIG_SCALING_VIDEO_EXAMPLE 0 ++#define CONFIG_TRANSCODE_AAC_EXAMPLE 0 ++#define CONFIG_TRANSCODING_EXAMPLE 0 ++#define CONFIG_VAAPI_ENCODE_EXAMPLE 0 ++#define CONFIG_VAAPI_TRANSCODE_EXAMPLE 0 ++#define CONFIG_AVISYNTH 0 ++#define CONFIG_FREI0R 0 ++#define CONFIG_LIBCDIO 0 ++#define CONFIG_LIBDAVS2 0 ++#define CONFIG_LIBRUBBERBAND 0 ++#define CONFIG_LIBVIDSTAB 0 ++#define CONFIG_LIBX264 0 ++#define CONFIG_LIBX265 0 ++#define CONFIG_LIBXAVS 0 ++#define CONFIG_LIBXAVS2 0 ++#define CONFIG_LIBXVID 0 ++#define CONFIG_DECKLINK 0 ++#define CONFIG_LIBNDI_NEWTEK 0 ++#define CONFIG_LIBFDK_AAC 0 ++#define CONFIG_OPENSSL 0 ++#define CONFIG_LIBTLS 0 ++#define CONFIG_GMP 0 ++#define CONFIG_LIBLENSFUN 0 ++#define CONFIG_LIBOPENCORE_AMRNB 0 ++#define CONFIG_LIBOPENCORE_AMRWB 0 ++#define CONFIG_LIBVMAF 0 ++#define CONFIG_LIBVO_AMRWBENC 0 ++#define CONFIG_MBEDTLS 0 ++#define CONFIG_RKMPP 0 ++#define CONFIG_LIBSMBCLIENT 0 ++#define CONFIG_CHROMAPRINT 0 ++#define CONFIG_GCRYPT 0 ++#define CONFIG_GNUTLS 0 ++#define CONFIG_JNI 0 ++#define CONFIG_LADSPA 0 ++#define CONFIG_LIBAOM 0 ++#define CONFIG_LIBASS 0 ++#define CONFIG_LIBBLURAY 0 ++#define CONFIG_LIBBS2B 0 ++#define CONFIG_LIBCACA 0 ++#define CONFIG_LIBCELT 0 ++#define CONFIG_LIBCODEC2 0 ++#define CONFIG_LIBDAV1D 0 ++#define CONFIG_LIBDC1394 0 ++#define CONFIG_LIBDRM 0 ++#define CONFIG_LIBFLITE 0 ++#define CONFIG_LIBFONTCONFIG 0 ++#define CONFIG_LIBFREETYPE 0 ++#define CONFIG_LIBFRIBIDI 0 ++#define CONFIG_LIBGME 0 ++#define CONFIG_LIBGSM 0 ++#define CONFIG_LIBIEC61883 0 ++#define CONFIG_LIBILBC 0 ++#define CONFIG_LIBJACK 0 ++#define CONFIG_LIBKLVANC 0 ++#define CONFIG_LIBKVAZAAR 0 ++#define CONFIG_LIBMODPLUG 0 ++#define CONFIG_LIBMP3LAME 0 ++#define CONFIG_LIBMYSOFA 0 ++#define CONFIG_LIBOPENCV 0 ++#define CONFIG_LIBOPENH264 0 ++#define CONFIG_LIBOPENJPEG 0 ++#define CONFIG_LIBOPENMPT 0 ++#define CONFIG_LIBOPUS 1 ++#define CONFIG_LIBPULSE 0 ++#define CONFIG_LIBRSVG 0 ++#define CONFIG_LIBRTMP 0 ++#define CONFIG_LIBSHINE 0 ++#define CONFIG_LIBSMBCLIENT 0 ++#define CONFIG_LIBSNAPPY 0 ++#define CONFIG_LIBSOXR 0 ++#define CONFIG_LIBSPEEX 0 ++#define CONFIG_LIBSRT 0 ++#define CONFIG_LIBSSH 0 ++#define CONFIG_LIBTENSORFLOW 0 ++#define CONFIG_LIBTESSERACT 0 ++#define CONFIG_LIBTHEORA 0 ++#define CONFIG_LIBTWOLAME 0 ++#define CONFIG_LIBV4L2 0 ++#define CONFIG_LIBVORBIS 0 ++#define CONFIG_LIBVPX 0 ++#define CONFIG_LIBWAVPACK 0 ++#define CONFIG_LIBWEBP 0 ++#define CONFIG_LIBXML2 0 ++#define CONFIG_LIBZIMG 0 ++#define CONFIG_LIBZMQ 0 ++#define CONFIG_LIBZVBI 0 ++#define CONFIG_LV2 0 ++#define CONFIG_MEDIACODEC 0 ++#define CONFIG_OPENAL 0 ++#define CONFIG_OPENGL 0 ++#define CONFIG_VAPOURSYNTH 0 ++#define CONFIG_ALSA 1 ++#define CONFIG_APPKIT 0 ++#define CONFIG_AVFOUNDATION 0 ++#define CONFIG_BZLIB 0 ++#define CONFIG_COREIMAGE 0 ++#define CONFIG_ICONV 0 ++#define CONFIG_LIBXCB 0 ++#define CONFIG_LIBXCB_SHM 0 ++#define CONFIG_LIBXCB_SHAPE 0 ++#define CONFIG_LIBXCB_XFIXES 0 ++#define CONFIG_LZMA 0 ++#define CONFIG_SCHANNEL 0 ++#define CONFIG_SDL2 0 ++#define CONFIG_SECURETRANSPORT 0 ++#define CONFIG_SNDIO 0 ++#define CONFIG_XLIB 0 ++#define CONFIG_ZLIB 0 ++#define CONFIG_CUDA_SDK 0 ++#define CONFIG_LIBNPP 0 ++#define CONFIG_LIBMFX 0 ++#define CONFIG_MMAL 0 ++#define CONFIG_OMX 0 ++#define CONFIG_OPENCL 0 ++#define CONFIG_AMF 0 ++#define CONFIG_AUDIOTOOLBOX 0 ++#define CONFIG_CRYSTALHD 0 ++#define CONFIG_CUDA 0 ++#define CONFIG_CUVID 0 ++#define CONFIG_D3D11VA 0 ++#define CONFIG_DXVA2 0 ++#define CONFIG_FFNVCODEC 0 ++#define CONFIG_NVDEC 0 ++#define CONFIG_NVENC 0 ++#define CONFIG_VAAPI 0 ++#define CONFIG_VDPAU 0 ++#define CONFIG_VIDEOTOOLBOX 0 ++#define CONFIG_V4L2_M2M 0 ++#define CONFIG_XVMC 0 ++#define CONFIG_FTRAPV 0 ++#define CONFIG_GRAY 0 ++#define CONFIG_HARDCODED_TABLES 0 ++#define CONFIG_OMX_RPI 0 ++#define CONFIG_RUNTIME_CPUDETECT 1 ++#define CONFIG_SAFE_BITSTREAM_READER 1 ++#define CONFIG_SHARED 0 ++#define CONFIG_SMALL 0 ++#define CONFIG_STATIC 1 ++#define CONFIG_SWSCALE_ALPHA 1 ++#define CONFIG_GPL 0 ++#define CONFIG_NONFREE 0 ++#define CONFIG_VERSION3 0 ++#define CONFIG_AVDEVICE 0 ++#define CONFIG_AVFILTER 0 ++#define CONFIG_SWSCALE 0 ++#define CONFIG_POSTPROC 0 ++#define CONFIG_AVFORMAT 1 ++#define CONFIG_AVCODEC 1 ++#define CONFIG_SWRESAMPLE 0 ++#define CONFIG_AVRESAMPLE 0 ++#define CONFIG_AVUTIL 1 ++#define CONFIG_FFPLAY 0 ++#define CONFIG_FFPROBE 0 ++#define CONFIG_FFMPEG 0 ++#define CONFIG_DCT 1 ++#define CONFIG_DWT 0 ++#define CONFIG_ERROR_RESILIENCE 0 ++#define CONFIG_FAAN 0 ++#define CONFIG_FAST_UNALIGNED 1 ++#define CONFIG_FFT 1 ++#define CONFIG_LSP 0 ++#define CONFIG_LZO 0 ++#define CONFIG_MDCT 1 ++#define CONFIG_PIXELUTILS 0 ++#define CONFIG_NETWORK 0 ++#define CONFIG_RDFT 1 ++#define CONFIG_AUTODETECT 0 ++#define CONFIG_FONTCONFIG 0 ++#define CONFIG_LINUX_PERF 0 ++#define CONFIG_MEMORY_POISONING 0 ++#define CONFIG_NEON_CLOBBER_TEST 0 ++#define CONFIG_OSSFUZZ 0 ++#define CONFIG_PIC 1 ++#define CONFIG_THUMB 0 ++#define CONFIG_VALGRIND_BACKTRACE 0 ++#define CONFIG_XMM_CLOBBER_TEST 0 ++#define CONFIG_BSFS 1 ++#define CONFIG_DECODERS 1 ++#define CONFIG_ENCODERS 0 ++#define CONFIG_HWACCELS 0 ++#define CONFIG_PARSERS 1 ++#define CONFIG_INDEVS 0 ++#define CONFIG_OUTDEVS 0 ++#define CONFIG_FILTERS 0 ++#define CONFIG_DEMUXERS 1 ++#define CONFIG_MUXERS 0 ++#define CONFIG_PROTOCOLS 0 ++#define CONFIG_AANDCTTABLES 0 ++#define CONFIG_AC3DSP 0 ++#define CONFIG_ADTS_HEADER 1 ++#define CONFIG_AUDIO_FRAME_QUEUE 0 ++#define CONFIG_AUDIODSP 0 ++#define CONFIG_BLOCKDSP 0 ++#define CONFIG_BSWAPDSP 0 ++#define CONFIG_CABAC 1 ++#define CONFIG_CBS 0 ++#define CONFIG_CBS_AV1 0 ++#define CONFIG_CBS_H264 0 ++#define CONFIG_CBS_H265 0 ++#define CONFIG_CBS_JPEG 0 ++#define CONFIG_CBS_MPEG2 0 ++#define CONFIG_CBS_VP9 0 ++#define CONFIG_DIRAC_PARSE 1 ++#define CONFIG_DNN 0 ++#define CONFIG_DVPROFILE 0 ++#define CONFIG_EXIF 0 ++#define CONFIG_FAANDCT 0 ++#define CONFIG_FAANIDCT 0 ++#define CONFIG_FDCTDSP 0 ++#define CONFIG_FLACDSP 1 ++#define CONFIG_FMTCONVERT 0 ++#define CONFIG_FRAME_THREAD_ENCODER 0 ++#define CONFIG_G722DSP 0 ++#define CONFIG_GOLOMB 1 ++#define CONFIG_GPLV3 0 ++#define CONFIG_H263DSP 0 ++#define CONFIG_H264CHROMA 1 ++#define CONFIG_H264DSP 1 ++#define CONFIG_H264PARSE 1 ++#define CONFIG_H264PRED 1 ++#define CONFIG_H264QPEL 1 ++#define CONFIG_HEVCPARSE 0 ++#define CONFIG_HPELDSP 1 ++#define CONFIG_HUFFMAN 0 ++#define CONFIG_HUFFYUVDSP 0 ++#define CONFIG_HUFFYUVENCDSP 0 ++#define CONFIG_IDCTDSP 0 ++#define CONFIG_IIRFILTER 0 ++#define CONFIG_MDCT15 1 ++#define CONFIG_INTRAX8 0 ++#define CONFIG_ISO_MEDIA 1 ++#define CONFIG_IVIDSP 0 ++#define CONFIG_JPEGTABLES 0 ++#define CONFIG_LGPLV3 0 ++#define CONFIG_LIBX262 0 ++#define CONFIG_LLAUDDSP 0 ++#define CONFIG_LLVIDDSP 0 ++#define CONFIG_LLVIDENCDSP 0 ++#define CONFIG_LPC 0 ++#define CONFIG_LZF 0 ++#define CONFIG_ME_CMP 0 ++#define CONFIG_MPEG_ER 0 ++#define CONFIG_MPEGAUDIO 1 ++#define CONFIG_MPEGAUDIODSP 1 ++#define CONFIG_MPEGAUDIOHEADER 1 ++#define CONFIG_MPEGVIDEO 0 ++#define CONFIG_MPEGVIDEOENC 0 ++#define CONFIG_MSS34DSP 0 ++#define CONFIG_PIXBLOCKDSP 0 ++#define CONFIG_QPELDSP 0 ++#define CONFIG_QSV 0 ++#define CONFIG_QSVDEC 0 ++#define CONFIG_QSVENC 0 ++#define CONFIG_QSVVPP 0 ++#define CONFIG_RANGECODER 0 ++#define CONFIG_RIFFDEC 1 ++#define CONFIG_RIFFENC 0 ++#define CONFIG_RTPDEC 0 ++#define CONFIG_RTPENC_CHAIN 0 ++#define CONFIG_RV34DSP 0 ++#define CONFIG_SCENE_SAD 0 ++#define CONFIG_SINEWIN 1 ++#define CONFIG_SNAPPY 0 ++#define CONFIG_SRTP 0 ++#define CONFIG_STARTCODE 1 ++#define CONFIG_TEXTUREDSP 0 ++#define CONFIG_TEXTUREDSPENC 0 ++#define CONFIG_TPELDSP 0 ++#define CONFIG_VAAPI_1 0 ++#define CONFIG_VAAPI_ENCODE 0 ++#define CONFIG_VC1DSP 0 ++#define CONFIG_VIDEODSP 1 ++#define CONFIG_VP3DSP 1 ++#define CONFIG_VP56DSP 0 ++#define CONFIG_VP8DSP 1 ++#define CONFIG_WMA_FREQS 0 ++#define CONFIG_WMV2DSP 0 ++#define CONFIG_AAC_ADTSTOASC_BSF 0 ++#define CONFIG_AV1_METADATA_BSF 0 ++#define CONFIG_CHOMP_BSF 0 ++#define CONFIG_DUMP_EXTRADATA_BSF 0 ++#define CONFIG_DCA_CORE_BSF 0 ++#define CONFIG_EAC3_CORE_BSF 0 ++#define CONFIG_EXTRACT_EXTRADATA_BSF 0 ++#define CONFIG_FILTER_UNITS_BSF 0 ++#define CONFIG_H264_METADATA_BSF 0 ++#define CONFIG_H264_MP4TOANNEXB_BSF 0 ++#define CONFIG_H264_REDUNDANT_PPS_BSF 0 ++#define CONFIG_HAPQA_EXTRACT_BSF 0 ++#define CONFIG_HEVC_METADATA_BSF 0 ++#define CONFIG_HEVC_MP4TOANNEXB_BSF 0 ++#define CONFIG_IMX_DUMP_HEADER_BSF 0 ++#define CONFIG_MJPEG2JPEG_BSF 0 ++#define CONFIG_MJPEGA_DUMP_HEADER_BSF 0 ++#define CONFIG_MP3_HEADER_DECOMPRESS_BSF 0 ++#define CONFIG_MPEG2_METADATA_BSF 0 ++#define CONFIG_MPEG4_UNPACK_BFRAMES_BSF 0 ++#define CONFIG_MOV2TEXTSUB_BSF 0 ++#define CONFIG_NOISE_BSF 0 ++#define CONFIG_NULL_BSF 1 ++#define CONFIG_PRORES_METADATA_BSF 0 ++#define CONFIG_REMOVE_EXTRADATA_BSF 0 ++#define CONFIG_TEXT2MOVSUB_BSF 0 ++#define CONFIG_TRACE_HEADERS_BSF 0 ++#define CONFIG_TRUEHD_CORE_BSF 0 ++#define CONFIG_VP9_METADATA_BSF 0 ++#define CONFIG_VP9_RAW_REORDER_BSF 0 ++#define CONFIG_VP9_SUPERFRAME_BSF 0 ++#define CONFIG_VP9_SUPERFRAME_SPLIT_BSF 0 ++#define CONFIG_AASC_DECODER 0 ++#define CONFIG_AIC_DECODER 0 ++#define CONFIG_ALIAS_PIX_DECODER 0 ++#define CONFIG_AMV_DECODER 0 ++#define CONFIG_ANM_DECODER 0 ++#define CONFIG_ANSI_DECODER 0 ++#define CONFIG_APNG_DECODER 0 ++#define CONFIG_ASV1_DECODER 0 ++#define CONFIG_ASV2_DECODER 0 ++#define CONFIG_AURA_DECODER 0 ++#define CONFIG_AURA2_DECODER 0 ++#define CONFIG_AVRP_DECODER 0 ++#define CONFIG_AVRN_DECODER 0 ++#define CONFIG_AVS_DECODER 0 ++#define CONFIG_AVUI_DECODER 0 ++#define CONFIG_AYUV_DECODER 0 ++#define CONFIG_BETHSOFTVID_DECODER 0 ++#define CONFIG_BFI_DECODER 0 ++#define CONFIG_BINK_DECODER 0 ++#define CONFIG_BITPACKED_DECODER 0 ++#define CONFIG_BMP_DECODER 0 ++#define CONFIG_BMV_VIDEO_DECODER 0 ++#define CONFIG_BRENDER_PIX_DECODER 0 ++#define CONFIG_C93_DECODER 0 ++#define CONFIG_CAVS_DECODER 0 ++#define CONFIG_CDGRAPHICS_DECODER 0 ++#define CONFIG_CDXL_DECODER 0 ++#define CONFIG_CFHD_DECODER 0 ++#define CONFIG_CINEPAK_DECODER 0 ++#define CONFIG_CLEARVIDEO_DECODER 0 ++#define CONFIG_CLJR_DECODER 0 ++#define CONFIG_CLLC_DECODER 0 ++#define CONFIG_COMFORTNOISE_DECODER 0 ++#define CONFIG_CPIA_DECODER 0 ++#define CONFIG_CSCD_DECODER 0 ++#define CONFIG_CYUV_DECODER 0 ++#define CONFIG_DDS_DECODER 0 ++#define CONFIG_DFA_DECODER 0 ++#define CONFIG_DIRAC_DECODER 0 ++#define CONFIG_DNXHD_DECODER 0 ++#define CONFIG_DPX_DECODER 0 ++#define CONFIG_DSICINVIDEO_DECODER 0 ++#define CONFIG_DVAUDIO_DECODER 0 ++#define CONFIG_DVVIDEO_DECODER 0 ++#define CONFIG_DXA_DECODER 0 ++#define CONFIG_DXTORY_DECODER 0 ++#define CONFIG_DXV_DECODER 0 ++#define CONFIG_EACMV_DECODER 0 ++#define CONFIG_EAMAD_DECODER 0 ++#define CONFIG_EATGQ_DECODER 0 ++#define CONFIG_EATGV_DECODER 0 ++#define CONFIG_EATQI_DECODER 0 ++#define CONFIG_EIGHTBPS_DECODER 0 ++#define CONFIG_EIGHTSVX_EXP_DECODER 0 ++#define CONFIG_EIGHTSVX_FIB_DECODER 0 ++#define CONFIG_ESCAPE124_DECODER 0 ++#define CONFIG_ESCAPE130_DECODER 0 ++#define CONFIG_EXR_DECODER 0 ++#define CONFIG_FFV1_DECODER 0 ++#define CONFIG_FFVHUFF_DECODER 0 ++#define CONFIG_FIC_DECODER 0 ++#define CONFIG_FITS_DECODER 0 ++#define CONFIG_FLASHSV_DECODER 0 ++#define CONFIG_FLASHSV2_DECODER 0 ++#define CONFIG_FLIC_DECODER 0 ++#define CONFIG_FLV_DECODER 0 ++#define CONFIG_FMVC_DECODER 0 ++#define CONFIG_FOURXM_DECODER 0 ++#define CONFIG_FRAPS_DECODER 0 ++#define CONFIG_FRWU_DECODER 0 ++#define CONFIG_G2M_DECODER 0 ++#define CONFIG_GDV_DECODER 0 ++#define CONFIG_GIF_DECODER 0 ++#define CONFIG_H261_DECODER 0 ++#define CONFIG_H263_DECODER 0 ++#define CONFIG_H263I_DECODER 0 ++#define CONFIG_H263P_DECODER 0 ++#define CONFIG_H263_V4L2M2M_DECODER 0 ++#define CONFIG_H264_DECODER 1 ++#define CONFIG_H264_CRYSTALHD_DECODER 0 ++#define CONFIG_H264_V4L2M2M_DECODER 0 ++#define CONFIG_H264_MEDIACODEC_DECODER 0 ++#define CONFIG_H264_MMAL_DECODER 0 ++#define CONFIG_H264_QSV_DECODER 0 ++#define CONFIG_H264_RKMPP_DECODER 0 ++#define CONFIG_HAP_DECODER 0 ++#define CONFIG_HEVC_DECODER 0 ++#define CONFIG_HEVC_QSV_DECODER 0 ++#define CONFIG_HEVC_RKMPP_DECODER 0 ++#define CONFIG_HEVC_V4L2M2M_DECODER 0 ++#define CONFIG_HNM4_VIDEO_DECODER 0 ++#define CONFIG_HQ_HQA_DECODER 0 ++#define CONFIG_HQX_DECODER 0 ++#define CONFIG_HUFFYUV_DECODER 0 ++#define CONFIG_IDCIN_DECODER 0 ++#define CONFIG_IFF_ILBM_DECODER 0 ++#define CONFIG_IMM4_DECODER 0 ++#define CONFIG_INDEO2_DECODER 0 ++#define CONFIG_INDEO3_DECODER 0 ++#define CONFIG_INDEO4_DECODER 0 ++#define CONFIG_INDEO5_DECODER 0 ++#define CONFIG_INTERPLAY_VIDEO_DECODER 0 ++#define CONFIG_JPEG2000_DECODER 0 ++#define CONFIG_JPEGLS_DECODER 0 ++#define CONFIG_JV_DECODER 0 ++#define CONFIG_KGV1_DECODER 0 ++#define CONFIG_KMVC_DECODER 0 ++#define CONFIG_LAGARITH_DECODER 0 ++#define CONFIG_LOCO_DECODER 0 ++#define CONFIG_M101_DECODER 0 ++#define CONFIG_MAGICYUV_DECODER 0 ++#define CONFIG_MDEC_DECODER 0 ++#define CONFIG_MIMIC_DECODER 0 ++#define CONFIG_MJPEG_DECODER 0 ++#define CONFIG_MJPEGB_DECODER 0 ++#define CONFIG_MMVIDEO_DECODER 0 ++#define CONFIG_MOTIONPIXELS_DECODER 0 ++#define CONFIG_MPEG1VIDEO_DECODER 0 ++#define CONFIG_MPEG2VIDEO_DECODER 0 ++#define CONFIG_MPEG4_DECODER 0 ++#define CONFIG_MPEG4_CRYSTALHD_DECODER 0 ++#define CONFIG_MPEG4_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG4_MMAL_DECODER 0 ++#define CONFIG_MPEGVIDEO_DECODER 0 ++#define CONFIG_MPEG1_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG2_MMAL_DECODER 0 ++#define CONFIG_MPEG2_CRYSTALHD_DECODER 0 ++#define CONFIG_MPEG2_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG2_QSV_DECODER 0 ++#define CONFIG_MPEG2_MEDIACODEC_DECODER 0 ++#define CONFIG_MSA1_DECODER 0 ++#define CONFIG_MSCC_DECODER 0 ++#define CONFIG_MSMPEG4V1_DECODER 0 ++#define CONFIG_MSMPEG4V2_DECODER 0 ++#define CONFIG_MSMPEG4V3_DECODER 0 ++#define CONFIG_MSMPEG4_CRYSTALHD_DECODER 0 ++#define CONFIG_MSRLE_DECODER 0 ++#define CONFIG_MSS1_DECODER 0 ++#define CONFIG_MSS2_DECODER 0 ++#define CONFIG_MSVIDEO1_DECODER 0 ++#define CONFIG_MSZH_DECODER 0 ++#define CONFIG_MTS2_DECODER 0 ++#define CONFIG_MVC1_DECODER 0 ++#define CONFIG_MVC2_DECODER 0 ++#define CONFIG_MWSC_DECODER 0 ++#define CONFIG_MXPEG_DECODER 0 ++#define CONFIG_NUV_DECODER 0 ++#define CONFIG_PAF_VIDEO_DECODER 0 ++#define CONFIG_PAM_DECODER 0 ++#define CONFIG_PBM_DECODER 0 ++#define CONFIG_PCX_DECODER 0 ++#define CONFIG_PGM_DECODER 0 ++#define CONFIG_PGMYUV_DECODER 0 ++#define CONFIG_PICTOR_DECODER 0 ++#define CONFIG_PIXLET_DECODER 0 ++#define CONFIG_PNG_DECODER 0 ++#define CONFIG_PPM_DECODER 0 ++#define CONFIG_PRORES_DECODER 0 ++#define CONFIG_PROSUMER_DECODER 0 ++#define CONFIG_PSD_DECODER 0 ++#define CONFIG_PTX_DECODER 0 ++#define CONFIG_QDRAW_DECODER 0 ++#define CONFIG_QPEG_DECODER 0 ++#define CONFIG_QTRLE_DECODER 0 ++#define CONFIG_R10K_DECODER 0 ++#define CONFIG_R210_DECODER 0 ++#define CONFIG_RASC_DECODER 0 ++#define CONFIG_RAWVIDEO_DECODER 0 ++#define CONFIG_RL2_DECODER 0 ++#define CONFIG_ROQ_DECODER 0 ++#define CONFIG_RPZA_DECODER 0 ++#define CONFIG_RSCC_DECODER 0 ++#define CONFIG_RV10_DECODER 0 ++#define CONFIG_RV20_DECODER 0 ++#define CONFIG_RV30_DECODER 0 ++#define CONFIG_RV40_DECODER 0 ++#define CONFIG_S302M_DECODER 0 ++#define CONFIG_SANM_DECODER 0 ++#define CONFIG_SCPR_DECODER 0 ++#define CONFIG_SCREENPRESSO_DECODER 0 ++#define CONFIG_SDX2_DPCM_DECODER 0 ++#define CONFIG_SGI_DECODER 0 ++#define CONFIG_SGIRLE_DECODER 0 ++#define CONFIG_SHEERVIDEO_DECODER 0 ++#define CONFIG_SMACKER_DECODER 0 ++#define CONFIG_SMC_DECODER 0 ++#define CONFIG_SMVJPEG_DECODER 0 ++#define CONFIG_SNOW_DECODER 0 ++#define CONFIG_SP5X_DECODER 0 ++#define CONFIG_SPEEDHQ_DECODER 0 ++#define CONFIG_SRGC_DECODER 0 ++#define CONFIG_SUNRAST_DECODER 0 ++#define CONFIG_SVQ1_DECODER 0 ++#define CONFIG_SVQ3_DECODER 0 ++#define CONFIG_TARGA_DECODER 0 ++#define CONFIG_TARGA_Y216_DECODER 0 ++#define CONFIG_TDSC_DECODER 0 ++#define CONFIG_THEORA_DECODER 1 ++#define CONFIG_THP_DECODER 0 ++#define CONFIG_TIERTEXSEQVIDEO_DECODER 0 ++#define CONFIG_TIFF_DECODER 0 ++#define CONFIG_TMV_DECODER 0 ++#define CONFIG_TRUEMOTION1_DECODER 0 ++#define CONFIG_TRUEMOTION2_DECODER 0 ++#define CONFIG_TRUEMOTION2RT_DECODER 0 ++#define CONFIG_TSCC_DECODER 0 ++#define CONFIG_TSCC2_DECODER 0 ++#define CONFIG_TXD_DECODER 0 ++#define CONFIG_ULTI_DECODER 0 ++#define CONFIG_UTVIDEO_DECODER 0 ++#define CONFIG_V210_DECODER 0 ++#define CONFIG_V210X_DECODER 0 ++#define CONFIG_V308_DECODER 0 ++#define CONFIG_V408_DECODER 0 ++#define CONFIG_V410_DECODER 0 ++#define CONFIG_VB_DECODER 0 ++#define CONFIG_VBLE_DECODER 0 ++#define CONFIG_VC1_DECODER 0 ++#define CONFIG_VC1_CRYSTALHD_DECODER 0 ++#define CONFIG_VC1IMAGE_DECODER 0 ++#define CONFIG_VC1_MMAL_DECODER 0 ++#define CONFIG_VC1_QSV_DECODER 0 ++#define CONFIG_VC1_V4L2M2M_DECODER 0 ++#define CONFIG_VCR1_DECODER 0 ++#define CONFIG_VMDVIDEO_DECODER 0 ++#define CONFIG_VMNC_DECODER 0 ++#define CONFIG_VP3_DECODER 1 ++#define CONFIG_VP5_DECODER 0 ++#define CONFIG_VP6_DECODER 0 ++#define CONFIG_VP6A_DECODER 0 ++#define CONFIG_VP6F_DECODER 0 ++#define CONFIG_VP7_DECODER 0 ++#define CONFIG_VP8_DECODER 1 ++#define CONFIG_VP8_RKMPP_DECODER 0 ++#define CONFIG_VP8_V4L2M2M_DECODER 0 ++#define CONFIG_VP9_DECODER 0 ++#define CONFIG_VP9_RKMPP_DECODER 0 ++#define CONFIG_VP9_V4L2M2M_DECODER 0 ++#define CONFIG_VQA_DECODER 0 ++#define CONFIG_WEBP_DECODER 0 ++#define CONFIG_WCMV_DECODER 0 ++#define CONFIG_WRAPPED_AVFRAME_DECODER 0 ++#define CONFIG_WMV1_DECODER 0 ++#define CONFIG_WMV2_DECODER 0 ++#define CONFIG_WMV3_DECODER 0 ++#define CONFIG_WMV3_CRYSTALHD_DECODER 0 ++#define CONFIG_WMV3IMAGE_DECODER 0 ++#define CONFIG_WNV1_DECODER 0 ++#define CONFIG_XAN_WC3_DECODER 0 ++#define CONFIG_XAN_WC4_DECODER 0 ++#define CONFIG_XBM_DECODER 0 ++#define CONFIG_XFACE_DECODER 0 ++#define CONFIG_XL_DECODER 0 ++#define CONFIG_XPM_DECODER 0 ++#define CONFIG_XWD_DECODER 0 ++#define CONFIG_Y41P_DECODER 0 ++#define CONFIG_YLC_DECODER 0 ++#define CONFIG_YOP_DECODER 0 ++#define CONFIG_YUV4_DECODER 0 ++#define CONFIG_ZERO12V_DECODER 0 ++#define CONFIG_ZEROCODEC_DECODER 0 ++#define CONFIG_ZLIB_DECODER 0 ++#define CONFIG_ZMBV_DECODER 0 ++#define CONFIG_AAC_DECODER 1 ++#define CONFIG_AAC_FIXED_DECODER 0 ++#define CONFIG_AAC_LATM_DECODER 0 ++#define CONFIG_AC3_DECODER 0 ++#define CONFIG_AC3_FIXED_DECODER 0 ++#define CONFIG_ALAC_DECODER 0 ++#define CONFIG_ALS_DECODER 0 ++#define CONFIG_AMRNB_DECODER 0 ++#define CONFIG_AMRWB_DECODER 0 ++#define CONFIG_APE_DECODER 0 ++#define CONFIG_APTX_DECODER 0 ++#define CONFIG_APTX_HD_DECODER 0 ++#define CONFIG_ATRAC1_DECODER 0 ++#define CONFIG_ATRAC3_DECODER 0 ++#define CONFIG_ATRAC3AL_DECODER 0 ++#define CONFIG_ATRAC3P_DECODER 0 ++#define CONFIG_ATRAC3PAL_DECODER 0 ++#define CONFIG_ATRAC9_DECODER 0 ++#define CONFIG_BINKAUDIO_DCT_DECODER 0 ++#define CONFIG_BINKAUDIO_RDFT_DECODER 0 ++#define CONFIG_BMV_AUDIO_DECODER 0 ++#define CONFIG_COOK_DECODER 0 ++#define CONFIG_DCA_DECODER 0 ++#define CONFIG_DOLBY_E_DECODER 0 ++#define CONFIG_DSD_LSBF_DECODER 0 ++#define CONFIG_DSD_MSBF_DECODER 0 ++#define CONFIG_DSD_LSBF_PLANAR_DECODER 0 ++#define CONFIG_DSD_MSBF_PLANAR_DECODER 0 ++#define CONFIG_DSICINAUDIO_DECODER 0 ++#define CONFIG_DSS_SP_DECODER 0 ++#define CONFIG_DST_DECODER 0 ++#define CONFIG_EAC3_DECODER 0 ++#define CONFIG_EVRC_DECODER 0 ++#define CONFIG_FFWAVESYNTH_DECODER 0 ++#define CONFIG_FLAC_DECODER 1 ++#define CONFIG_G723_1_DECODER 0 ++#define CONFIG_G729_DECODER 0 ++#define CONFIG_GSM_DECODER 0 ++#define CONFIG_GSM_MS_DECODER 0 ++#define CONFIG_IAC_DECODER 0 ++#define CONFIG_ILBC_DECODER 0 ++#define CONFIG_IMC_DECODER 0 ++#define CONFIG_INTERPLAY_ACM_DECODER 0 ++#define CONFIG_MACE3_DECODER 0 ++#define CONFIG_MACE6_DECODER 0 ++#define CONFIG_METASOUND_DECODER 0 ++#define CONFIG_MLP_DECODER 0 ++#define CONFIG_MP1_DECODER 0 ++#define CONFIG_MP1FLOAT_DECODER 0 ++#define CONFIG_MP2_DECODER 0 ++#define CONFIG_MP2FLOAT_DECODER 0 ++#define CONFIG_MP3FLOAT_DECODER 0 ++#define CONFIG_MP3_DECODER 1 ++#define CONFIG_MP3ADUFLOAT_DECODER 0 ++#define CONFIG_MP3ADU_DECODER 0 ++#define CONFIG_MP3ON4FLOAT_DECODER 0 ++#define CONFIG_MP3ON4_DECODER 0 ++#define CONFIG_MPC7_DECODER 0 ++#define CONFIG_MPC8_DECODER 0 ++#define CONFIG_NELLYMOSER_DECODER 0 ++#define CONFIG_ON2AVC_DECODER 0 ++#define CONFIG_OPUS_DECODER 0 ++#define CONFIG_PAF_AUDIO_DECODER 0 ++#define CONFIG_QCELP_DECODER 0 ++#define CONFIG_QDM2_DECODER 0 ++#define CONFIG_QDMC_DECODER 0 ++#define CONFIG_RA_144_DECODER 0 ++#define CONFIG_RA_288_DECODER 0 ++#define CONFIG_RALF_DECODER 0 ++#define CONFIG_SBC_DECODER 0 ++#define CONFIG_SHORTEN_DECODER 0 ++#define CONFIG_SIPR_DECODER 0 ++#define CONFIG_SMACKAUD_DECODER 0 ++#define CONFIG_SONIC_DECODER 0 ++#define CONFIG_TAK_DECODER 0 ++#define CONFIG_TRUEHD_DECODER 0 ++#define CONFIG_TRUESPEECH_DECODER 0 ++#define CONFIG_TTA_DECODER 0 ++#define CONFIG_TWINVQ_DECODER 0 ++#define CONFIG_VMDAUDIO_DECODER 0 ++#define CONFIG_VORBIS_DECODER 1 ++#define CONFIG_WAVPACK_DECODER 0 ++#define CONFIG_WMALOSSLESS_DECODER 0 ++#define CONFIG_WMAPRO_DECODER 0 ++#define CONFIG_WMAV1_DECODER 0 ++#define CONFIG_WMAV2_DECODER 0 ++#define CONFIG_WMAVOICE_DECODER 0 ++#define CONFIG_WS_SND1_DECODER 0 ++#define CONFIG_XMA1_DECODER 0 ++#define CONFIG_XMA2_DECODER 0 ++#define CONFIG_PCM_ALAW_DECODER 1 ++#define CONFIG_PCM_BLURAY_DECODER 0 ++#define CONFIG_PCM_DVD_DECODER 0 ++#define CONFIG_PCM_F16LE_DECODER 0 ++#define CONFIG_PCM_F24LE_DECODER 0 ++#define CONFIG_PCM_F32BE_DECODER 0 ++#define CONFIG_PCM_F32LE_DECODER 1 ++#define CONFIG_PCM_F64BE_DECODER 0 ++#define CONFIG_PCM_F64LE_DECODER 0 ++#define CONFIG_PCM_LXF_DECODER 0 ++#define CONFIG_PCM_MULAW_DECODER 1 ++#define CONFIG_PCM_S8_DECODER 0 ++#define CONFIG_PCM_S8_PLANAR_DECODER 0 ++#define CONFIG_PCM_S16BE_DECODER 1 ++#define CONFIG_PCM_S16BE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S16LE_DECODER 1 ++#define CONFIG_PCM_S16LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S24BE_DECODER 1 ++#define CONFIG_PCM_S24DAUD_DECODER 0 ++#define CONFIG_PCM_S24LE_DECODER 1 ++#define CONFIG_PCM_S24LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S32BE_DECODER 0 ++#define CONFIG_PCM_S32LE_DECODER 1 ++#define CONFIG_PCM_S32LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S64BE_DECODER 0 ++#define CONFIG_PCM_S64LE_DECODER 0 ++#define CONFIG_PCM_U8_DECODER 1 ++#define CONFIG_PCM_U16BE_DECODER 0 ++#define CONFIG_PCM_U16LE_DECODER 0 ++#define CONFIG_PCM_U24BE_DECODER 0 ++#define CONFIG_PCM_U24LE_DECODER 0 ++#define CONFIG_PCM_U32BE_DECODER 0 ++#define CONFIG_PCM_U32LE_DECODER 0 ++#define CONFIG_PCM_VIDC_DECODER 0 ++#define CONFIG_PCM_ZORK_DECODER 0 ++#define CONFIG_GREMLIN_DPCM_DECODER 0 ++#define CONFIG_INTERPLAY_DPCM_DECODER 0 ++#define CONFIG_ROQ_DPCM_DECODER 0 ++#define CONFIG_SOL_DPCM_DECODER 0 ++#define CONFIG_XAN_DPCM_DECODER 0 ++#define CONFIG_ADPCM_4XM_DECODER 0 ++#define CONFIG_ADPCM_ADX_DECODER 0 ++#define CONFIG_ADPCM_AFC_DECODER 0 ++#define CONFIG_ADPCM_AICA_DECODER 0 ++#define CONFIG_ADPCM_CT_DECODER 0 ++#define CONFIG_ADPCM_DTK_DECODER 0 ++#define CONFIG_ADPCM_EA_DECODER 0 ++#define CONFIG_ADPCM_EA_MAXIS_XA_DECODER 0 ++#define CONFIG_ADPCM_EA_R1_DECODER 0 ++#define CONFIG_ADPCM_EA_R2_DECODER 0 ++#define CONFIG_ADPCM_EA_R3_DECODER 0 ++#define CONFIG_ADPCM_EA_XAS_DECODER 0 ++#define CONFIG_ADPCM_G722_DECODER 0 ++#define CONFIG_ADPCM_G726_DECODER 0 ++#define CONFIG_ADPCM_G726LE_DECODER 0 ++#define CONFIG_ADPCM_IMA_AMV_DECODER 0 ++#define CONFIG_ADPCM_IMA_APC_DECODER 0 ++#define CONFIG_ADPCM_IMA_DAT4_DECODER 0 ++#define CONFIG_ADPCM_IMA_DK3_DECODER 0 ++#define CONFIG_ADPCM_IMA_DK4_DECODER 0 ++#define CONFIG_ADPCM_IMA_EA_EACS_DECODER 0 ++#define CONFIG_ADPCM_IMA_EA_SEAD_DECODER 0 ++#define CONFIG_ADPCM_IMA_ISS_DECODER 0 ++#define CONFIG_ADPCM_IMA_OKI_DECODER 0 ++#define CONFIG_ADPCM_IMA_QT_DECODER 0 ++#define CONFIG_ADPCM_IMA_RAD_DECODER 0 ++#define CONFIG_ADPCM_IMA_SMJPEG_DECODER 0 ++#define CONFIG_ADPCM_IMA_WAV_DECODER 0 ++#define CONFIG_ADPCM_IMA_WS_DECODER 0 ++#define CONFIG_ADPCM_MS_DECODER 0 ++#define CONFIG_ADPCM_MTAF_DECODER 0 ++#define CONFIG_ADPCM_PSX_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_2_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_3_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_4_DECODER 0 ++#define CONFIG_ADPCM_SWF_DECODER 0 ++#define CONFIG_ADPCM_THP_DECODER 0 ++#define CONFIG_ADPCM_THP_LE_DECODER 0 ++#define CONFIG_ADPCM_VIMA_DECODER 0 ++#define CONFIG_ADPCM_XA_DECODER 0 ++#define CONFIG_ADPCM_YAMAHA_DECODER 0 ++#define CONFIG_SSA_DECODER 0 ++#define CONFIG_ASS_DECODER 0 ++#define CONFIG_CCAPTION_DECODER 0 ++#define CONFIG_DVBSUB_DECODER 0 ++#define CONFIG_DVDSUB_DECODER 0 ++#define CONFIG_JACOSUB_DECODER 0 ++#define CONFIG_MICRODVD_DECODER 0 ++#define CONFIG_MOVTEXT_DECODER 0 ++#define CONFIG_MPL2_DECODER 0 ++#define CONFIG_PGSSUB_DECODER 0 ++#define CONFIG_PJS_DECODER 0 ++#define CONFIG_REALTEXT_DECODER 0 ++#define CONFIG_SAMI_DECODER 0 ++#define CONFIG_SRT_DECODER 0 ++#define CONFIG_STL_DECODER 0 ++#define CONFIG_SUBRIP_DECODER 0 ++#define CONFIG_SUBVIEWER_DECODER 0 ++#define CONFIG_SUBVIEWER1_DECODER 0 ++#define CONFIG_TEXT_DECODER 0 ++#define CONFIG_VPLAYER_DECODER 0 ++#define CONFIG_WEBVTT_DECODER 0 ++#define CONFIG_XSUB_DECODER 0 ++#define CONFIG_AAC_AT_DECODER 0 ++#define CONFIG_AC3_AT_DECODER 0 ++#define CONFIG_ADPCM_IMA_QT_AT_DECODER 0 ++#define CONFIG_ALAC_AT_DECODER 0 ++#define CONFIG_AMR_NB_AT_DECODER 0 ++#define CONFIG_EAC3_AT_DECODER 0 ++#define CONFIG_GSM_MS_AT_DECODER 0 ++#define CONFIG_ILBC_AT_DECODER 0 ++#define CONFIG_MP1_AT_DECODER 0 ++#define CONFIG_MP2_AT_DECODER 0 ++#define CONFIG_MP3_AT_DECODER 0 ++#define CONFIG_PCM_ALAW_AT_DECODER 0 ++#define CONFIG_PCM_MULAW_AT_DECODER 0 ++#define CONFIG_QDMC_AT_DECODER 0 ++#define CONFIG_QDM2_AT_DECODER 0 ++#define CONFIG_LIBAOM_AV1_DECODER 0 ++#define CONFIG_LIBCELT_DECODER 0 ++#define CONFIG_LIBCODEC2_DECODER 0 ++#define CONFIG_LIBDAV1D_DECODER 0 ++#define CONFIG_LIBDAVS2_DECODER 0 ++#define CONFIG_LIBFDK_AAC_DECODER 0 ++#define CONFIG_LIBGSM_DECODER 0 ++#define CONFIG_LIBGSM_MS_DECODER 0 ++#define CONFIG_LIBILBC_DECODER 0 ++#define CONFIG_LIBOPENCORE_AMRNB_DECODER 0 ++#define CONFIG_LIBOPENCORE_AMRWB_DECODER 0 ++#define CONFIG_LIBOPENJPEG_DECODER 0 ++#define CONFIG_LIBOPUS_DECODER 1 ++#define CONFIG_LIBRSVG_DECODER 0 ++#define CONFIG_LIBSPEEX_DECODER 0 ++#define CONFIG_LIBVORBIS_DECODER 0 ++#define CONFIG_LIBVPX_VP8_DECODER 0 ++#define CONFIG_LIBVPX_VP9_DECODER 0 ++#define CONFIG_LIBZVBI_TELETEXT_DECODER 0 ++#define CONFIG_BINTEXT_DECODER 0 ++#define CONFIG_XBIN_DECODER 0 ++#define CONFIG_IDF_DECODER 0 ++#define CONFIG_LIBOPENH264_DECODER 0 ++#define CONFIG_H264_CUVID_DECODER 0 ++#define CONFIG_HEVC_CUVID_DECODER 0 ++#define CONFIG_HEVC_MEDIACODEC_DECODER 0 ++#define CONFIG_MJPEG_CUVID_DECODER 0 ++#define CONFIG_MPEG1_CUVID_DECODER 0 ++#define CONFIG_MPEG2_CUVID_DECODER 0 ++#define CONFIG_MPEG4_CUVID_DECODER 0 ++#define CONFIG_MPEG4_MEDIACODEC_DECODER 0 ++#define CONFIG_VC1_CUVID_DECODER 0 ++#define CONFIG_VP8_CUVID_DECODER 0 ++#define CONFIG_VP8_MEDIACODEC_DECODER 0 ++#define CONFIG_VP8_QSV_DECODER 0 ++#define CONFIG_VP9_CUVID_DECODER 0 ++#define CONFIG_VP9_MEDIACODEC_DECODER 0 ++#define CONFIG_A64MULTI_ENCODER 0 ++#define CONFIG_A64MULTI5_ENCODER 0 ++#define CONFIG_ALIAS_PIX_ENCODER 0 ++#define CONFIG_AMV_ENCODER 0 ++#define CONFIG_APNG_ENCODER 0 ++#define CONFIG_ASV1_ENCODER 0 ++#define CONFIG_ASV2_ENCODER 0 ++#define CONFIG_AVRP_ENCODER 0 ++#define CONFIG_AVUI_ENCODER 0 ++#define CONFIG_AYUV_ENCODER 0 ++#define CONFIG_BMP_ENCODER 0 ++#define CONFIG_CINEPAK_ENCODER 0 ++#define CONFIG_CLJR_ENCODER 0 ++#define CONFIG_COMFORTNOISE_ENCODER 0 ++#define CONFIG_DNXHD_ENCODER 0 ++#define CONFIG_DPX_ENCODER 0 ++#define CONFIG_DVVIDEO_ENCODER 0 ++#define CONFIG_FFV1_ENCODER 0 ++#define CONFIG_FFVHUFF_ENCODER 0 ++#define CONFIG_FITS_ENCODER 0 ++#define CONFIG_FLASHSV_ENCODER 0 ++#define CONFIG_FLASHSV2_ENCODER 0 ++#define CONFIG_FLV_ENCODER 0 ++#define CONFIG_GIF_ENCODER 0 ++#define CONFIG_H261_ENCODER 0 ++#define CONFIG_H263_ENCODER 0 ++#define CONFIG_H263P_ENCODER 0 ++#define CONFIG_HAP_ENCODER 0 ++#define CONFIG_HUFFYUV_ENCODER 0 ++#define CONFIG_JPEG2000_ENCODER 0 ++#define CONFIG_JPEGLS_ENCODER 0 ++#define CONFIG_LJPEG_ENCODER 0 ++#define CONFIG_MAGICYUV_ENCODER 0 ++#define CONFIG_MJPEG_ENCODER 0 ++#define CONFIG_MPEG1VIDEO_ENCODER 0 ++#define CONFIG_MPEG2VIDEO_ENCODER 0 ++#define CONFIG_MPEG4_ENCODER 0 ++#define CONFIG_MSMPEG4V2_ENCODER 0 ++#define CONFIG_MSMPEG4V3_ENCODER 0 ++#define CONFIG_MSVIDEO1_ENCODER 0 ++#define CONFIG_PAM_ENCODER 0 ++#define CONFIG_PBM_ENCODER 0 ++#define CONFIG_PCX_ENCODER 0 ++#define CONFIG_PGM_ENCODER 0 ++#define CONFIG_PGMYUV_ENCODER 0 ++#define CONFIG_PNG_ENCODER 0 ++#define CONFIG_PPM_ENCODER 0 ++#define CONFIG_PRORES_ENCODER 0 ++#define CONFIG_PRORES_AW_ENCODER 0 ++#define CONFIG_PRORES_KS_ENCODER 0 ++#define CONFIG_QTRLE_ENCODER 0 ++#define CONFIG_R10K_ENCODER 0 ++#define CONFIG_R210_ENCODER 0 ++#define CONFIG_RAWVIDEO_ENCODER 0 ++#define CONFIG_ROQ_ENCODER 0 ++#define CONFIG_RV10_ENCODER 0 ++#define CONFIG_RV20_ENCODER 0 ++#define CONFIG_S302M_ENCODER 0 ++#define CONFIG_SGI_ENCODER 0 ++#define CONFIG_SNOW_ENCODER 0 ++#define CONFIG_SUNRAST_ENCODER 0 ++#define CONFIG_SVQ1_ENCODER 0 ++#define CONFIG_TARGA_ENCODER 0 ++#define CONFIG_TIFF_ENCODER 0 ++#define CONFIG_UTVIDEO_ENCODER 0 ++#define CONFIG_V210_ENCODER 0 ++#define CONFIG_V308_ENCODER 0 ++#define CONFIG_V408_ENCODER 0 ++#define CONFIG_V410_ENCODER 0 ++#define CONFIG_VC2_ENCODER 0 ++#define CONFIG_WRAPPED_AVFRAME_ENCODER 0 ++#define CONFIG_WMV1_ENCODER 0 ++#define CONFIG_WMV2_ENCODER 0 ++#define CONFIG_XBM_ENCODER 0 ++#define CONFIG_XFACE_ENCODER 0 ++#define CONFIG_XWD_ENCODER 0 ++#define CONFIG_Y41P_ENCODER 0 ++#define CONFIG_YUV4_ENCODER 0 ++#define CONFIG_ZLIB_ENCODER 0 ++#define CONFIG_ZMBV_ENCODER 0 ++#define CONFIG_AAC_ENCODER 0 ++#define CONFIG_AC3_ENCODER 0 ++#define CONFIG_AC3_FIXED_ENCODER 0 ++#define CONFIG_ALAC_ENCODER 0 ++#define CONFIG_APTX_ENCODER 0 ++#define CONFIG_APTX_HD_ENCODER 0 ++#define CONFIG_DCA_ENCODER 0 ++#define CONFIG_EAC3_ENCODER 0 ++#define CONFIG_FLAC_ENCODER 0 ++#define CONFIG_G723_1_ENCODER 0 ++#define CONFIG_MLP_ENCODER 0 ++#define CONFIG_MP2_ENCODER 0 ++#define CONFIG_MP2FIXED_ENCODER 0 ++#define CONFIG_NELLYMOSER_ENCODER 0 ++#define CONFIG_OPUS_ENCODER 0 ++#define CONFIG_RA_144_ENCODER 0 ++#define CONFIG_SBC_ENCODER 0 ++#define CONFIG_SONIC_ENCODER 0 ++#define CONFIG_SONIC_LS_ENCODER 0 ++#define CONFIG_TRUEHD_ENCODER 0 ++#define CONFIG_TTA_ENCODER 0 ++#define CONFIG_VORBIS_ENCODER 0 ++#define CONFIG_WAVPACK_ENCODER 0 ++#define CONFIG_WMAV1_ENCODER 0 ++#define CONFIG_WMAV2_ENCODER 0 ++#define CONFIG_PCM_ALAW_ENCODER 0 ++#define CONFIG_PCM_F32BE_ENCODER 0 ++#define CONFIG_PCM_F32LE_ENCODER 0 ++#define CONFIG_PCM_F64BE_ENCODER 0 ++#define CONFIG_PCM_F64LE_ENCODER 0 ++#define CONFIG_PCM_MULAW_ENCODER 0 ++#define CONFIG_PCM_S8_ENCODER 0 ++#define CONFIG_PCM_S8_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S16BE_ENCODER 0 ++#define CONFIG_PCM_S16BE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S16LE_ENCODER 0 ++#define CONFIG_PCM_S16LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S24BE_ENCODER 0 ++#define CONFIG_PCM_S24DAUD_ENCODER 0 ++#define CONFIG_PCM_S24LE_ENCODER 0 ++#define CONFIG_PCM_S24LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S32BE_ENCODER 0 ++#define CONFIG_PCM_S32LE_ENCODER 0 ++#define CONFIG_PCM_S32LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S64BE_ENCODER 0 ++#define CONFIG_PCM_S64LE_ENCODER 0 ++#define CONFIG_PCM_U8_ENCODER 0 ++#define CONFIG_PCM_U16BE_ENCODER 0 ++#define CONFIG_PCM_U16LE_ENCODER 0 ++#define CONFIG_PCM_U24BE_ENCODER 0 ++#define CONFIG_PCM_U24LE_ENCODER 0 ++#define CONFIG_PCM_U32BE_ENCODER 0 ++#define CONFIG_PCM_U32LE_ENCODER 0 ++#define CONFIG_PCM_VIDC_ENCODER 0 ++#define CONFIG_ROQ_DPCM_ENCODER 0 ++#define CONFIG_ADPCM_ADX_ENCODER 0 ++#define CONFIG_ADPCM_G722_ENCODER 0 ++#define CONFIG_ADPCM_G726_ENCODER 0 ++#define CONFIG_ADPCM_G726LE_ENCODER 0 ++#define CONFIG_ADPCM_IMA_QT_ENCODER 0 ++#define CONFIG_ADPCM_IMA_WAV_ENCODER 0 ++#define CONFIG_ADPCM_MS_ENCODER 0 ++#define CONFIG_ADPCM_SWF_ENCODER 0 ++#define CONFIG_ADPCM_YAMAHA_ENCODER 0 ++#define CONFIG_SSA_ENCODER 0 ++#define CONFIG_ASS_ENCODER 0 ++#define CONFIG_DVBSUB_ENCODER 0 ++#define CONFIG_DVDSUB_ENCODER 0 ++#define CONFIG_MOVTEXT_ENCODER 0 ++#define CONFIG_SRT_ENCODER 0 ++#define CONFIG_SUBRIP_ENCODER 0 ++#define CONFIG_TEXT_ENCODER 0 ++#define CONFIG_WEBVTT_ENCODER 0 ++#define CONFIG_XSUB_ENCODER 0 ++#define CONFIG_AAC_AT_ENCODER 0 ++#define CONFIG_ALAC_AT_ENCODER 0 ++#define CONFIG_ILBC_AT_ENCODER 0 ++#define CONFIG_PCM_ALAW_AT_ENCODER 0 ++#define CONFIG_PCM_MULAW_AT_ENCODER 0 ++#define CONFIG_LIBAOM_AV1_ENCODER 0 ++#define CONFIG_LIBCODEC2_ENCODER 0 ++#define CONFIG_LIBFDK_AAC_ENCODER 0 ++#define CONFIG_LIBGSM_ENCODER 0 ++#define CONFIG_LIBGSM_MS_ENCODER 0 ++#define CONFIG_LIBILBC_ENCODER 0 ++#define CONFIG_LIBMP3LAME_ENCODER 0 ++#define CONFIG_LIBOPENCORE_AMRNB_ENCODER 0 ++#define CONFIG_LIBOPENJPEG_ENCODER 0 ++#define CONFIG_LIBOPUS_ENCODER 0 ++#define CONFIG_LIBSHINE_ENCODER 0 ++#define CONFIG_LIBSPEEX_ENCODER 0 ++#define CONFIG_LIBTHEORA_ENCODER 0 ++#define CONFIG_LIBTWOLAME_ENCODER 0 ++#define CONFIG_LIBVO_AMRWBENC_ENCODER 0 ++#define CONFIG_LIBVORBIS_ENCODER 0 ++#define CONFIG_LIBVPX_VP8_ENCODER 0 ++#define CONFIG_LIBVPX_VP9_ENCODER 0 ++#define CONFIG_LIBWAVPACK_ENCODER 0 ++#define CONFIG_LIBWEBP_ANIM_ENCODER 0 ++#define CONFIG_LIBWEBP_ENCODER 0 ++#define CONFIG_LIBX262_ENCODER 0 ++#define CONFIG_LIBX264_ENCODER 0 ++#define CONFIG_LIBX264RGB_ENCODER 0 ++#define CONFIG_LIBX265_ENCODER 0 ++#define CONFIG_LIBXAVS_ENCODER 0 ++#define CONFIG_LIBXAVS2_ENCODER 0 ++#define CONFIG_LIBXVID_ENCODER 0 ++#define CONFIG_H263_V4L2M2M_ENCODER 0 ++#define CONFIG_LIBOPENH264_ENCODER 0 ++#define CONFIG_H264_AMF_ENCODER 0 ++#define CONFIG_H264_NVENC_ENCODER 0 ++#define CONFIG_H264_OMX_ENCODER 0 ++#define CONFIG_H264_QSV_ENCODER 0 ++#define CONFIG_H264_V4L2M2M_ENCODER 0 ++#define CONFIG_H264_VAAPI_ENCODER 0 ++#define CONFIG_H264_VIDEOTOOLBOX_ENCODER 0 ++#define CONFIG_NVENC_ENCODER 0 ++#define CONFIG_NVENC_H264_ENCODER 0 ++#define CONFIG_NVENC_HEVC_ENCODER 0 ++#define CONFIG_HEVC_AMF_ENCODER 0 ++#define CONFIG_HEVC_NVENC_ENCODER 0 ++#define CONFIG_HEVC_QSV_ENCODER 0 ++#define CONFIG_HEVC_V4L2M2M_ENCODER 0 ++#define CONFIG_HEVC_VAAPI_ENCODER 0 ++#define CONFIG_HEVC_VIDEOTOOLBOX_ENCODER 0 ++#define CONFIG_LIBKVAZAAR_ENCODER 0 ++#define CONFIG_MJPEG_QSV_ENCODER 0 ++#define CONFIG_MJPEG_VAAPI_ENCODER 0 ++#define CONFIG_MPEG2_QSV_ENCODER 0 ++#define CONFIG_MPEG2_VAAPI_ENCODER 0 ++#define CONFIG_MPEG4_V4L2M2M_ENCODER 0 ++#define CONFIG_VP8_V4L2M2M_ENCODER 0 ++#define CONFIG_VP8_VAAPI_ENCODER 0 ++#define CONFIG_VP9_VAAPI_ENCODER 0 ++#define CONFIG_H263_VAAPI_HWACCEL 0 ++#define CONFIG_H263_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_H264_D3D11VA_HWACCEL 0 ++#define CONFIG_H264_D3D11VA2_HWACCEL 0 ++#define CONFIG_H264_DXVA2_HWACCEL 0 ++#define CONFIG_H264_NVDEC_HWACCEL 0 ++#define CONFIG_H264_VAAPI_HWACCEL 0 ++#define CONFIG_H264_VDPAU_HWACCEL 0 ++#define CONFIG_H264_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_HEVC_D3D11VA_HWACCEL 0 ++#define CONFIG_HEVC_D3D11VA2_HWACCEL 0 ++#define CONFIG_HEVC_DXVA2_HWACCEL 0 ++#define CONFIG_HEVC_NVDEC_HWACCEL 0 ++#define CONFIG_HEVC_VAAPI_HWACCEL 0 ++#define CONFIG_HEVC_VDPAU_HWACCEL 0 ++#define CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MJPEG_NVDEC_HWACCEL 0 ++#define CONFIG_MJPEG_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG1_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG1_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MPEG1_XVMC_HWACCEL 0 ++#define CONFIG_MPEG2_D3D11VA_HWACCEL 0 ++#define CONFIG_MPEG2_D3D11VA2_HWACCEL 0 ++#define CONFIG_MPEG2_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG2_DXVA2_HWACCEL 0 ++#define CONFIG_MPEG2_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG2_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MPEG2_XVMC_HWACCEL 0 ++#define CONFIG_MPEG4_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG4_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG4_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_VC1_D3D11VA_HWACCEL 0 ++#define CONFIG_VC1_D3D11VA2_HWACCEL 0 ++#define CONFIG_VC1_DXVA2_HWACCEL 0 ++#define CONFIG_VC1_NVDEC_HWACCEL 0 ++#define CONFIG_VC1_VAAPI_HWACCEL 0 ++#define CONFIG_VC1_VDPAU_HWACCEL 0 ++#define CONFIG_VP8_NVDEC_HWACCEL 0 ++#define CONFIG_VP8_VAAPI_HWACCEL 0 ++#define CONFIG_VP9_D3D11VA_HWACCEL 0 ++#define CONFIG_VP9_D3D11VA2_HWACCEL 0 ++#define CONFIG_VP9_DXVA2_HWACCEL 0 ++#define CONFIG_VP9_NVDEC_HWACCEL 0 ++#define CONFIG_VP9_VAAPI_HWACCEL 0 ++#define CONFIG_WMV3_D3D11VA_HWACCEL 0 ++#define CONFIG_WMV3_D3D11VA2_HWACCEL 0 ++#define CONFIG_WMV3_DXVA2_HWACCEL 0 ++#define CONFIG_WMV3_NVDEC_HWACCEL 0 ++#define CONFIG_WMV3_VAAPI_HWACCEL 0 ++#define CONFIG_WMV3_VDPAU_HWACCEL 0 ++#define CONFIG_AAC_PARSER 1 ++#define CONFIG_AAC_LATM_PARSER 0 ++#define CONFIG_AC3_PARSER 0 ++#define CONFIG_ADX_PARSER 0 ++#define CONFIG_AV1_PARSER 0 ++#define CONFIG_AVS2_PARSER 0 ++#define CONFIG_BMP_PARSER 0 ++#define CONFIG_CAVSVIDEO_PARSER 0 ++#define CONFIG_COOK_PARSER 0 ++#define CONFIG_DCA_PARSER 0 ++#define CONFIG_DIRAC_PARSER 0 ++#define CONFIG_DNXHD_PARSER 0 ++#define CONFIG_DPX_PARSER 0 ++#define CONFIG_DVAUDIO_PARSER 0 ++#define CONFIG_DVBSUB_PARSER 0 ++#define CONFIG_DVDSUB_PARSER 0 ++#define CONFIG_DVD_NAV_PARSER 0 ++#define CONFIG_FLAC_PARSER 1 ++#define CONFIG_G729_PARSER 0 ++#define CONFIG_GSM_PARSER 0 ++#define CONFIG_H261_PARSER 0 ++#define CONFIG_H263_PARSER 0 ++#define CONFIG_H264_PARSER 1 ++#define CONFIG_HEVC_PARSER 0 ++#define CONFIG_MJPEG_PARSER 0 ++#define CONFIG_MLP_PARSER 0 ++#define CONFIG_MPEG4VIDEO_PARSER 0 ++#define CONFIG_MPEGAUDIO_PARSER 1 ++#define CONFIG_MPEGVIDEO_PARSER 0 ++#define CONFIG_OPUS_PARSER 1 ++#define CONFIG_PNG_PARSER 0 ++#define CONFIG_PNM_PARSER 0 ++#define CONFIG_RV30_PARSER 0 ++#define CONFIG_RV40_PARSER 0 ++#define CONFIG_SBC_PARSER 0 ++#define CONFIG_SIPR_PARSER 0 ++#define CONFIG_TAK_PARSER 0 ++#define CONFIG_VC1_PARSER 0 ++#define CONFIG_VORBIS_PARSER 1 ++#define CONFIG_VP3_PARSER 1 ++#define CONFIG_VP8_PARSER 1 ++#define CONFIG_VP9_PARSER 0 ++#define CONFIG_XMA_PARSER 0 ++#define CONFIG_ALSA_INDEV 0 ++#define CONFIG_ANDROID_CAMERA_INDEV 0 ++#define CONFIG_AVFOUNDATION_INDEV 0 ++#define CONFIG_BKTR_INDEV 0 ++#define CONFIG_DECKLINK_INDEV 0 ++#define CONFIG_LIBNDI_NEWTEK_INDEV 0 ++#define CONFIG_DSHOW_INDEV 0 ++#define CONFIG_FBDEV_INDEV 0 ++#define CONFIG_GDIGRAB_INDEV 0 ++#define CONFIG_IEC61883_INDEV 0 ++#define CONFIG_JACK_INDEV 0 ++#define CONFIG_KMSGRAB_INDEV 0 ++#define CONFIG_LAVFI_INDEV 0 ++#define CONFIG_OPENAL_INDEV 0 ++#define CONFIG_OSS_INDEV 0 ++#define CONFIG_PULSE_INDEV 0 ++#define CONFIG_SNDIO_INDEV 0 ++#define CONFIG_V4L2_INDEV 0 ++#define CONFIG_VFWCAP_INDEV 0 ++#define CONFIG_XCBGRAB_INDEV 0 ++#define CONFIG_LIBCDIO_INDEV 0 ++#define CONFIG_LIBDC1394_INDEV 0 ++#define CONFIG_ALSA_OUTDEV 0 ++#define CONFIG_CACA_OUTDEV 0 ++#define CONFIG_DECKLINK_OUTDEV 0 ++#define CONFIG_LIBNDI_NEWTEK_OUTDEV 0 ++#define CONFIG_FBDEV_OUTDEV 0 ++#define CONFIG_OPENGL_OUTDEV 0 ++#define CONFIG_OSS_OUTDEV 0 ++#define CONFIG_PULSE_OUTDEV 0 ++#define CONFIG_SDL2_OUTDEV 0 ++#define CONFIG_SNDIO_OUTDEV 0 ++#define CONFIG_V4L2_OUTDEV 0 ++#define CONFIG_XV_OUTDEV 0 ++#define CONFIG_ABENCH_FILTER 0 ++#define CONFIG_ACOMPRESSOR_FILTER 0 ++#define CONFIG_ACONTRAST_FILTER 0 ++#define CONFIG_ACOPY_FILTER 0 ++#define CONFIG_ACUE_FILTER 0 ++#define CONFIG_ACROSSFADE_FILTER 0 ++#define CONFIG_ACROSSOVER_FILTER 0 ++#define CONFIG_ACRUSHER_FILTER 0 ++#define CONFIG_ADECLICK_FILTER 0 ++#define CONFIG_ADECLIP_FILTER 0 ++#define CONFIG_ADELAY_FILTER 0 ++#define CONFIG_ADERIVATIVE_FILTER 0 ++#define CONFIG_AECHO_FILTER 0 ++#define CONFIG_AEMPHASIS_FILTER 0 ++#define CONFIG_AEVAL_FILTER 0 ++#define CONFIG_AFADE_FILTER 0 ++#define CONFIG_AFFTDN_FILTER 0 ++#define CONFIG_AFFTFILT_FILTER 0 ++#define CONFIG_AFIR_FILTER 0 ++#define CONFIG_AFORMAT_FILTER 0 ++#define CONFIG_AGATE_FILTER 0 ++#define CONFIG_AIIR_FILTER 0 ++#define CONFIG_AINTEGRAL_FILTER 0 ++#define CONFIG_AINTERLEAVE_FILTER 0 ++#define CONFIG_ALIMITER_FILTER 0 ++#define CONFIG_ALLPASS_FILTER 0 ++#define CONFIG_ALOOP_FILTER 0 ++#define CONFIG_AMERGE_FILTER 0 ++#define CONFIG_AMETADATA_FILTER 0 ++#define CONFIG_AMIX_FILTER 0 ++#define CONFIG_AMULTIPLY_FILTER 0 ++#define CONFIG_ANEQUALIZER_FILTER 0 ++#define CONFIG_ANULL_FILTER 0 ++#define CONFIG_APAD_FILTER 0 ++#define CONFIG_APERMS_FILTER 0 ++#define CONFIG_APHASER_FILTER 0 ++#define CONFIG_APULSATOR_FILTER 0 ++#define CONFIG_AREALTIME_FILTER 0 ++#define CONFIG_ARESAMPLE_FILTER 0 ++#define CONFIG_AREVERSE_FILTER 0 ++#define CONFIG_ASELECT_FILTER 0 ++#define CONFIG_ASENDCMD_FILTER 0 ++#define CONFIG_ASETNSAMPLES_FILTER 0 ++#define CONFIG_ASETPTS_FILTER 0 ++#define CONFIG_ASETRATE_FILTER 0 ++#define CONFIG_ASETTB_FILTER 0 ++#define CONFIG_ASHOWINFO_FILTER 0 ++#define CONFIG_ASIDEDATA_FILTER 0 ++#define CONFIG_ASPLIT_FILTER 0 ++#define CONFIG_ASTATS_FILTER 0 ++#define CONFIG_ASTREAMSELECT_FILTER 0 ++#define CONFIG_ATEMPO_FILTER 0 ++#define CONFIG_ATRIM_FILTER 0 ++#define CONFIG_AZMQ_FILTER 0 ++#define CONFIG_BANDPASS_FILTER 0 ++#define CONFIG_BANDREJECT_FILTER 0 ++#define CONFIG_BASS_FILTER 0 ++#define CONFIG_BIQUAD_FILTER 0 ++#define CONFIG_BS2B_FILTER 0 ++#define CONFIG_CHANNELMAP_FILTER 0 ++#define CONFIG_CHANNELSPLIT_FILTER 0 ++#define CONFIG_CHORUS_FILTER 0 ++#define CONFIG_COMPAND_FILTER 0 ++#define CONFIG_COMPENSATIONDELAY_FILTER 0 ++#define CONFIG_CROSSFEED_FILTER 0 ++#define CONFIG_CRYSTALIZER_FILTER 0 ++#define CONFIG_DCSHIFT_FILTER 0 ++#define CONFIG_DRMETER_FILTER 0 ++#define CONFIG_DYNAUDNORM_FILTER 0 ++#define CONFIG_EARWAX_FILTER 0 ++#define CONFIG_EBUR128_FILTER 0 ++#define CONFIG_EQUALIZER_FILTER 0 ++#define CONFIG_EXTRASTEREO_FILTER 0 ++#define CONFIG_FIREQUALIZER_FILTER 0 ++#define CONFIG_FLANGER_FILTER 0 ++#define CONFIG_HAAS_FILTER 0 ++#define CONFIG_HDCD_FILTER 0 ++#define CONFIG_HEADPHONE_FILTER 0 ++#define CONFIG_HIGHPASS_FILTER 0 ++#define CONFIG_HIGHSHELF_FILTER 0 ++#define CONFIG_JOIN_FILTER 0 ++#define CONFIG_LADSPA_FILTER 0 ++#define CONFIG_LOUDNORM_FILTER 0 ++#define CONFIG_LOWPASS_FILTER 0 ++#define CONFIG_LOWSHELF_FILTER 0 ++#define CONFIG_LV2_FILTER 0 ++#define CONFIG_MCOMPAND_FILTER 0 ++#define CONFIG_PAN_FILTER 0 ++#define CONFIG_REPLAYGAIN_FILTER 0 ++#define CONFIG_RESAMPLE_FILTER 0 ++#define CONFIG_RUBBERBAND_FILTER 0 ++#define CONFIG_SIDECHAINCOMPRESS_FILTER 0 ++#define CONFIG_SIDECHAINGATE_FILTER 0 ++#define CONFIG_SILENCEDETECT_FILTER 0 ++#define CONFIG_SILENCEREMOVE_FILTER 0 ++#define CONFIG_SOFALIZER_FILTER 0 ++#define CONFIG_STEREOTOOLS_FILTER 0 ++#define CONFIG_STEREOWIDEN_FILTER 0 ++#define CONFIG_SUPEREQUALIZER_FILTER 0 ++#define CONFIG_SURROUND_FILTER 0 ++#define CONFIG_TREBLE_FILTER 0 ++#define CONFIG_TREMOLO_FILTER 0 ++#define CONFIG_VIBRATO_FILTER 0 ++#define CONFIG_VOLUME_FILTER 0 ++#define CONFIG_VOLUMEDETECT_FILTER 0 ++#define CONFIG_AEVALSRC_FILTER 0 ++#define CONFIG_ANOISESRC_FILTER 0 ++#define CONFIG_ANULLSRC_FILTER 0 ++#define CONFIG_FLITE_FILTER 0 ++#define CONFIG_HILBERT_FILTER 0 ++#define CONFIG_SINC_FILTER 0 ++#define CONFIG_SINE_FILTER 0 ++#define CONFIG_ANULLSINK_FILTER 0 ++#define CONFIG_ALPHAEXTRACT_FILTER 0 ++#define CONFIG_ALPHAMERGE_FILTER 0 ++#define CONFIG_AMPLIFY_FILTER 0 ++#define CONFIG_ASS_FILTER 0 ++#define CONFIG_ATADENOISE_FILTER 0 ++#define CONFIG_AVGBLUR_FILTER 0 ++#define CONFIG_AVGBLUR_OPENCL_FILTER 0 ++#define CONFIG_BBOX_FILTER 0 ++#define CONFIG_BENCH_FILTER 0 ++#define CONFIG_BITPLANENOISE_FILTER 0 ++#define CONFIG_BLACKDETECT_FILTER 0 ++#define CONFIG_BLACKFRAME_FILTER 0 ++#define CONFIG_BLEND_FILTER 0 ++#define CONFIG_BM3D_FILTER 0 ++#define CONFIG_BOXBLUR_FILTER 0 ++#define CONFIG_BOXBLUR_OPENCL_FILTER 0 ++#define CONFIG_BWDIF_FILTER 0 ++#define CONFIG_CHROMAHOLD_FILTER 0 ++#define CONFIG_CHROMAKEY_FILTER 0 ++#define CONFIG_CHROMASHIFT_FILTER 0 ++#define CONFIG_CIESCOPE_FILTER 0 ++#define CONFIG_CODECVIEW_FILTER 0 ++#define CONFIG_COLORBALANCE_FILTER 0 ++#define CONFIG_COLORCHANNELMIXER_FILTER 0 ++#define CONFIG_COLORKEY_FILTER 0 ++#define CONFIG_COLORLEVELS_FILTER 0 ++#define CONFIG_COLORMATRIX_FILTER 0 ++#define CONFIG_COLORSPACE_FILTER 0 ++#define CONFIG_CONVOLUTION_FILTER 0 ++#define CONFIG_CONVOLUTION_OPENCL_FILTER 0 ++#define CONFIG_CONVOLVE_FILTER 0 ++#define CONFIG_COPY_FILTER 0 ++#define CONFIG_COREIMAGE_FILTER 0 ++#define CONFIG_COVER_RECT_FILTER 0 ++#define CONFIG_CROP_FILTER 0 ++#define CONFIG_CROPDETECT_FILTER 0 ++#define CONFIG_CUE_FILTER 0 ++#define CONFIG_CURVES_FILTER 0 ++#define CONFIG_DATASCOPE_FILTER 0 ++#define CONFIG_DCTDNOIZ_FILTER 0 ++#define CONFIG_DEBAND_FILTER 0 ++#define CONFIG_DEBLOCK_FILTER 0 ++#define CONFIG_DECIMATE_FILTER 0 ++#define CONFIG_DECONVOLVE_FILTER 0 ++#define CONFIG_DEDOT_FILTER 0 ++#define CONFIG_DEFLATE_FILTER 0 ++#define CONFIG_DEFLICKER_FILTER 0 ++#define CONFIG_DEINTERLACE_QSV_FILTER 0 ++#define CONFIG_DEINTERLACE_VAAPI_FILTER 0 ++#define CONFIG_DEJUDDER_FILTER 0 ++#define CONFIG_DELOGO_FILTER 0 ++#define CONFIG_DENOISE_VAAPI_FILTER 0 ++#define CONFIG_DESHAKE_FILTER 0 ++#define CONFIG_DESPILL_FILTER 0 ++#define CONFIG_DETELECINE_FILTER 0 ++#define CONFIG_DILATION_FILTER 0 ++#define CONFIG_DILATION_OPENCL_FILTER 0 ++#define CONFIG_DISPLACE_FILTER 0 ++#define CONFIG_DOUBLEWEAVE_FILTER 0 ++#define CONFIG_DRAWBOX_FILTER 0 ++#define CONFIG_DRAWGRAPH_FILTER 0 ++#define CONFIG_DRAWGRID_FILTER 0 ++#define CONFIG_DRAWTEXT_FILTER 0 ++#define CONFIG_EDGEDETECT_FILTER 0 ++#define CONFIG_ELBG_FILTER 0 ++#define CONFIG_ENTROPY_FILTER 0 ++#define CONFIG_EQ_FILTER 0 ++#define CONFIG_EROSION_FILTER 0 ++#define CONFIG_EROSION_OPENCL_FILTER 0 ++#define CONFIG_EXTRACTPLANES_FILTER 0 ++#define CONFIG_FADE_FILTER 0 ++#define CONFIG_FFTDNOIZ_FILTER 0 ++#define CONFIG_FFTFILT_FILTER 0 ++#define CONFIG_FIELD_FILTER 0 ++#define CONFIG_FIELDHINT_FILTER 0 ++#define CONFIG_FIELDMATCH_FILTER 0 ++#define CONFIG_FIELDORDER_FILTER 0 ++#define CONFIG_FILLBORDERS_FILTER 0 ++#define CONFIG_FIND_RECT_FILTER 0 ++#define CONFIG_FLOODFILL_FILTER 0 ++#define CONFIG_FORMAT_FILTER 0 ++#define CONFIG_FPS_FILTER 0 ++#define CONFIG_FRAMEPACK_FILTER 0 ++#define CONFIG_FRAMERATE_FILTER 0 ++#define CONFIG_FRAMESTEP_FILTER 0 ++#define CONFIG_FREEZEDETECT_FILTER 0 ++#define CONFIG_FREI0R_FILTER 0 ++#define CONFIG_FSPP_FILTER 0 ++#define CONFIG_GBLUR_FILTER 0 ++#define CONFIG_GEQ_FILTER 0 ++#define CONFIG_GRADFUN_FILTER 0 ++#define CONFIG_GRAPHMONITOR_FILTER 0 ++#define CONFIG_GREYEDGE_FILTER 0 ++#define CONFIG_HALDCLUT_FILTER 0 ++#define CONFIG_HFLIP_FILTER 0 ++#define CONFIG_HISTEQ_FILTER 0 ++#define CONFIG_HISTOGRAM_FILTER 0 ++#define CONFIG_HQDN3D_FILTER 0 ++#define CONFIG_HQX_FILTER 0 ++#define CONFIG_HSTACK_FILTER 0 ++#define CONFIG_HUE_FILTER 0 ++#define CONFIG_HWDOWNLOAD_FILTER 0 ++#define CONFIG_HWMAP_FILTER 0 ++#define CONFIG_HWUPLOAD_FILTER 0 ++#define CONFIG_HWUPLOAD_CUDA_FILTER 0 ++#define CONFIG_HYSTERESIS_FILTER 0 ++#define CONFIG_IDET_FILTER 0 ++#define CONFIG_IL_FILTER 0 ++#define CONFIG_INFLATE_FILTER 0 ++#define CONFIG_INTERLACE_FILTER 0 ++#define CONFIG_INTERLEAVE_FILTER 0 ++#define CONFIG_KERNDEINT_FILTER 0 ++#define CONFIG_LENSCORRECTION_FILTER 0 ++#define CONFIG_LENSFUN_FILTER 0 ++#define CONFIG_LIBVMAF_FILTER 0 ++#define CONFIG_LIMITER_FILTER 0 ++#define CONFIG_LOOP_FILTER 0 ++#define CONFIG_LUMAKEY_FILTER 0 ++#define CONFIG_LUT_FILTER 0 ++#define CONFIG_LUT1D_FILTER 0 ++#define CONFIG_LUT2_FILTER 0 ++#define CONFIG_LUT3D_FILTER 0 ++#define CONFIG_LUTRGB_FILTER 0 ++#define CONFIG_LUTYUV_FILTER 0 ++#define CONFIG_MASKEDCLAMP_FILTER 0 ++#define CONFIG_MASKEDMERGE_FILTER 0 ++#define CONFIG_MCDEINT_FILTER 0 ++#define CONFIG_MERGEPLANES_FILTER 0 ++#define CONFIG_MESTIMATE_FILTER 0 ++#define CONFIG_METADATA_FILTER 0 ++#define CONFIG_MIDEQUALIZER_FILTER 0 ++#define CONFIG_MINTERPOLATE_FILTER 0 ++#define CONFIG_MIX_FILTER 0 ++#define CONFIG_MPDECIMATE_FILTER 0 ++#define CONFIG_NEGATE_FILTER 0 ++#define CONFIG_NLMEANS_FILTER 0 ++#define CONFIG_NNEDI_FILTER 0 ++#define CONFIG_NOFORMAT_FILTER 0 ++#define CONFIG_NOISE_FILTER 0 ++#define CONFIG_NORMALIZE_FILTER 0 ++#define CONFIG_NULL_FILTER 0 ++#define CONFIG_OCR_FILTER 0 ++#define CONFIG_OCV_FILTER 0 ++#define CONFIG_OSCILLOSCOPE_FILTER 0 ++#define CONFIG_OVERLAY_FILTER 0 ++#define CONFIG_OVERLAY_OPENCL_FILTER 0 ++#define CONFIG_OVERLAY_QSV_FILTER 0 ++#define CONFIG_OWDENOISE_FILTER 0 ++#define CONFIG_PAD_FILTER 0 ++#define CONFIG_PALETTEGEN_FILTER 0 ++#define CONFIG_PALETTEUSE_FILTER 0 ++#define CONFIG_PERMS_FILTER 0 ++#define CONFIG_PERSPECTIVE_FILTER 0 ++#define CONFIG_PHASE_FILTER 0 ++#define CONFIG_PIXDESCTEST_FILTER 0 ++#define CONFIG_PIXSCOPE_FILTER 0 ++#define CONFIG_PP_FILTER 0 ++#define CONFIG_PP7_FILTER 0 ++#define CONFIG_PREMULTIPLY_FILTER 0 ++#define CONFIG_PREWITT_FILTER 0 ++#define CONFIG_PREWITT_OPENCL_FILTER 0 ++#define CONFIG_PROCAMP_VAAPI_FILTER 0 ++#define CONFIG_PROGRAM_OPENCL_FILTER 0 ++#define CONFIG_PSEUDOCOLOR_FILTER 0 ++#define CONFIG_PSNR_FILTER 0 ++#define CONFIG_PULLUP_FILTER 0 ++#define CONFIG_QP_FILTER 0 ++#define CONFIG_RANDOM_FILTER 0 ++#define CONFIG_READEIA608_FILTER 0 ++#define CONFIG_READVITC_FILTER 0 ++#define CONFIG_REALTIME_FILTER 0 ++#define CONFIG_REMAP_FILTER 0 ++#define CONFIG_REMOVEGRAIN_FILTER 0 ++#define CONFIG_REMOVELOGO_FILTER 0 ++#define CONFIG_REPEATFIELDS_FILTER 0 ++#define CONFIG_REVERSE_FILTER 0 ++#define CONFIG_RGBASHIFT_FILTER 0 ++#define CONFIG_ROBERTS_FILTER 0 ++#define CONFIG_ROBERTS_OPENCL_FILTER 0 ++#define CONFIG_ROTATE_FILTER 0 ++#define CONFIG_SAB_FILTER 0 ++#define CONFIG_SCALE_FILTER 0 ++#define CONFIG_SCALE_CUDA_FILTER 0 ++#define CONFIG_SCALE_NPP_FILTER 0 ++#define CONFIG_SCALE_QSV_FILTER 0 ++#define CONFIG_SCALE_VAAPI_FILTER 0 ++#define CONFIG_SCALE2REF_FILTER 0 ++#define CONFIG_SELECT_FILTER 0 ++#define CONFIG_SELECTIVECOLOR_FILTER 0 ++#define CONFIG_SENDCMD_FILTER 0 ++#define CONFIG_SEPARATEFIELDS_FILTER 0 ++#define CONFIG_SETDAR_FILTER 0 ++#define CONFIG_SETFIELD_FILTER 0 ++#define CONFIG_SETPARAMS_FILTER 0 ++#define CONFIG_SETPTS_FILTER 0 ++#define CONFIG_SETRANGE_FILTER 0 ++#define CONFIG_SETSAR_FILTER 0 ++#define CONFIG_SETTB_FILTER 0 ++#define CONFIG_SHARPNESS_VAAPI_FILTER 0 ++#define CONFIG_SHOWINFO_FILTER 0 ++#define CONFIG_SHOWPALETTE_FILTER 0 ++#define CONFIG_SHUFFLEFRAMES_FILTER 0 ++#define CONFIG_SHUFFLEPLANES_FILTER 0 ++#define CONFIG_SIDEDATA_FILTER 0 ++#define CONFIG_SIGNALSTATS_FILTER 0 ++#define CONFIG_SIGNATURE_FILTER 0 ++#define CONFIG_SMARTBLUR_FILTER 0 ++#define CONFIG_SOBEL_FILTER 0 ++#define CONFIG_SOBEL_OPENCL_FILTER 0 ++#define CONFIG_SPLIT_FILTER 0 ++#define CONFIG_SPP_FILTER 0 ++#define CONFIG_SR_FILTER 0 ++#define CONFIG_SSIM_FILTER 0 ++#define CONFIG_STEREO3D_FILTER 0 ++#define CONFIG_STREAMSELECT_FILTER 0 ++#define CONFIG_SUBTITLES_FILTER 0 ++#define CONFIG_SUPER2XSAI_FILTER 0 ++#define CONFIG_SWAPRECT_FILTER 0 ++#define CONFIG_SWAPUV_FILTER 0 ++#define CONFIG_TBLEND_FILTER 0 ++#define CONFIG_TELECINE_FILTER 0 ++#define CONFIG_THRESHOLD_FILTER 0 ++#define CONFIG_THUMBNAIL_FILTER 0 ++#define CONFIG_THUMBNAIL_CUDA_FILTER 0 ++#define CONFIG_TILE_FILTER 0 ++#define CONFIG_TINTERLACE_FILTER 0 ++#define CONFIG_TLUT2_FILTER 0 ++#define CONFIG_TMIX_FILTER 0 ++#define CONFIG_TONEMAP_FILTER 0 ++#define CONFIG_TONEMAP_OPENCL_FILTER 0 ++#define CONFIG_TPAD_FILTER 0 ++#define CONFIG_TRANSPOSE_FILTER 0 ++#define CONFIG_TRANSPOSE_NPP_FILTER 0 ++#define CONFIG_TRIM_FILTER 0 ++#define CONFIG_UNPREMULTIPLY_FILTER 0 ++#define CONFIG_UNSHARP_FILTER 0 ++#define CONFIG_UNSHARP_OPENCL_FILTER 0 ++#define CONFIG_USPP_FILTER 0 ++#define CONFIG_VAGUEDENOISER_FILTER 0 ++#define CONFIG_VECTORSCOPE_FILTER 0 ++#define CONFIG_VFLIP_FILTER 0 ++#define CONFIG_VFRDET_FILTER 0 ++#define CONFIG_VIBRANCE_FILTER 0 ++#define CONFIG_VIDSTABDETECT_FILTER 0 ++#define CONFIG_VIDSTABTRANSFORM_FILTER 0 ++#define CONFIG_VIGNETTE_FILTER 0 ++#define CONFIG_VMAFMOTION_FILTER 0 ++#define CONFIG_VPP_QSV_FILTER 0 ++#define CONFIG_VSTACK_FILTER 0 ++#define CONFIG_W3FDIF_FILTER 0 ++#define CONFIG_WAVEFORM_FILTER 0 ++#define CONFIG_WEAVE_FILTER 0 ++#define CONFIG_XBR_FILTER 0 ++#define CONFIG_XSTACK_FILTER 0 ++#define CONFIG_YADIF_FILTER 0 ++#define CONFIG_YADIF_CUDA_FILTER 0 ++#define CONFIG_ZMQ_FILTER 0 ++#define CONFIG_ZOOMPAN_FILTER 0 ++#define CONFIG_ZSCALE_FILTER 0 ++#define CONFIG_ALLRGB_FILTER 0 ++#define CONFIG_ALLYUV_FILTER 0 ++#define CONFIG_CELLAUTO_FILTER 0 ++#define CONFIG_COLOR_FILTER 0 ++#define CONFIG_COREIMAGESRC_FILTER 0 ++#define CONFIG_FREI0R_SRC_FILTER 0 ++#define CONFIG_HALDCLUTSRC_FILTER 0 ++#define CONFIG_LIFE_FILTER 0 ++#define CONFIG_MANDELBROT_FILTER 0 ++#define CONFIG_MPTESTSRC_FILTER 0 ++#define CONFIG_NULLSRC_FILTER 0 ++#define CONFIG_OPENCLSRC_FILTER 0 ++#define CONFIG_PAL75BARS_FILTER 0 ++#define CONFIG_PAL100BARS_FILTER 0 ++#define CONFIG_RGBTESTSRC_FILTER 0 ++#define CONFIG_SMPTEBARS_FILTER 0 ++#define CONFIG_SMPTEHDBARS_FILTER 0 ++#define CONFIG_TESTSRC_FILTER 0 ++#define CONFIG_TESTSRC2_FILTER 0 ++#define CONFIG_YUVTESTSRC_FILTER 0 ++#define CONFIG_NULLSINK_FILTER 0 ++#define CONFIG_ABITSCOPE_FILTER 0 ++#define CONFIG_ADRAWGRAPH_FILTER 0 ++#define CONFIG_AGRAPHMONITOR_FILTER 0 ++#define CONFIG_AHISTOGRAM_FILTER 0 ++#define CONFIG_APHASEMETER_FILTER 0 ++#define CONFIG_AVECTORSCOPE_FILTER 0 ++#define CONFIG_CONCAT_FILTER 0 ++#define CONFIG_SHOWCQT_FILTER 0 ++#define CONFIG_SHOWFREQS_FILTER 0 ++#define CONFIG_SHOWSPECTRUM_FILTER 0 ++#define CONFIG_SHOWSPECTRUMPIC_FILTER 0 ++#define CONFIG_SHOWVOLUME_FILTER 0 ++#define CONFIG_SHOWWAVES_FILTER 0 ++#define CONFIG_SHOWWAVESPIC_FILTER 0 ++#define CONFIG_SPECTRUMSYNTH_FILTER 0 ++#define CONFIG_AMOVIE_FILTER 0 ++#define CONFIG_MOVIE_FILTER 0 ++#define CONFIG_AFIFO_FILTER 0 ++#define CONFIG_FIFO_FILTER 0 ++#define CONFIG_AA_DEMUXER 0 ++#define CONFIG_AAC_DEMUXER 1 ++#define CONFIG_AC3_DEMUXER 0 ++#define CONFIG_ACM_DEMUXER 0 ++#define CONFIG_ACT_DEMUXER 0 ++#define CONFIG_ADF_DEMUXER 0 ++#define CONFIG_ADP_DEMUXER 0 ++#define CONFIG_ADS_DEMUXER 0 ++#define CONFIG_ADX_DEMUXER 0 ++#define CONFIG_AEA_DEMUXER 0 ++#define CONFIG_AFC_DEMUXER 0 ++#define CONFIG_AIFF_DEMUXER 0 ++#define CONFIG_AIX_DEMUXER 0 ++#define CONFIG_AMR_DEMUXER 0 ++#define CONFIG_AMRNB_DEMUXER 0 ++#define CONFIG_AMRWB_DEMUXER 0 ++#define CONFIG_ANM_DEMUXER 0 ++#define CONFIG_APC_DEMUXER 0 ++#define CONFIG_APE_DEMUXER 0 ++#define CONFIG_APNG_DEMUXER 0 ++#define CONFIG_APTX_DEMUXER 0 ++#define CONFIG_APTX_HD_DEMUXER 0 ++#define CONFIG_AQTITLE_DEMUXER 0 ++#define CONFIG_ASF_DEMUXER 0 ++#define CONFIG_ASF_O_DEMUXER 0 ++#define CONFIG_ASS_DEMUXER 0 ++#define CONFIG_AST_DEMUXER 0 ++#define CONFIG_AU_DEMUXER 0 ++#define CONFIG_AVI_DEMUXER 0 ++#define CONFIG_AVISYNTH_DEMUXER 0 ++#define CONFIG_AVR_DEMUXER 0 ++#define CONFIG_AVS_DEMUXER 0 ++#define CONFIG_AVS2_DEMUXER 0 ++#define CONFIG_BETHSOFTVID_DEMUXER 0 ++#define CONFIG_BFI_DEMUXER 0 ++#define CONFIG_BINTEXT_DEMUXER 0 ++#define CONFIG_BINK_DEMUXER 0 ++#define CONFIG_BIT_DEMUXER 0 ++#define CONFIG_BMV_DEMUXER 0 ++#define CONFIG_BFSTM_DEMUXER 0 ++#define CONFIG_BRSTM_DEMUXER 0 ++#define CONFIG_BOA_DEMUXER 0 ++#define CONFIG_C93_DEMUXER 0 ++#define CONFIG_CAF_DEMUXER 0 ++#define CONFIG_CAVSVIDEO_DEMUXER 0 ++#define CONFIG_CDG_DEMUXER 0 ++#define CONFIG_CDXL_DEMUXER 0 ++#define CONFIG_CINE_DEMUXER 0 ++#define CONFIG_CODEC2_DEMUXER 0 ++#define CONFIG_CODEC2RAW_DEMUXER 0 ++#define CONFIG_CONCAT_DEMUXER 0 ++#define CONFIG_DASH_DEMUXER 0 ++#define CONFIG_DATA_DEMUXER 0 ++#define CONFIG_DAUD_DEMUXER 0 ++#define CONFIG_DCSTR_DEMUXER 0 ++#define CONFIG_DFA_DEMUXER 0 ++#define CONFIG_DHAV_DEMUXER 0 ++#define CONFIG_DIRAC_DEMUXER 0 ++#define CONFIG_DNXHD_DEMUXER 0 ++#define CONFIG_DSF_DEMUXER 0 ++#define CONFIG_DSICIN_DEMUXER 0 ++#define CONFIG_DSS_DEMUXER 0 ++#define CONFIG_DTS_DEMUXER 0 ++#define CONFIG_DTSHD_DEMUXER 0 ++#define CONFIG_DV_DEMUXER 0 ++#define CONFIG_DVBSUB_DEMUXER 0 ++#define CONFIG_DVBTXT_DEMUXER 0 ++#define CONFIG_DXA_DEMUXER 0 ++#define CONFIG_EA_DEMUXER 0 ++#define CONFIG_EA_CDATA_DEMUXER 0 ++#define CONFIG_EAC3_DEMUXER 0 ++#define CONFIG_EPAF_DEMUXER 0 ++#define CONFIG_FFMETADATA_DEMUXER 0 ++#define CONFIG_FILMSTRIP_DEMUXER 0 ++#define CONFIG_FITS_DEMUXER 0 ++#define CONFIG_FLAC_DEMUXER 1 ++#define CONFIG_FLIC_DEMUXER 0 ++#define CONFIG_FLV_DEMUXER 0 ++#define CONFIG_LIVE_FLV_DEMUXER 0 ++#define CONFIG_FOURXM_DEMUXER 0 ++#define CONFIG_FRM_DEMUXER 0 ++#define CONFIG_FSB_DEMUXER 0 ++#define CONFIG_G722_DEMUXER 0 ++#define CONFIG_G723_1_DEMUXER 0 ++#define CONFIG_G726_DEMUXER 0 ++#define CONFIG_G726LE_DEMUXER 0 ++#define CONFIG_G729_DEMUXER 0 ++#define CONFIG_GDV_DEMUXER 0 ++#define CONFIG_GENH_DEMUXER 0 ++#define CONFIG_GIF_DEMUXER 0 ++#define CONFIG_GSM_DEMUXER 0 ++#define CONFIG_GXF_DEMUXER 0 ++#define CONFIG_H261_DEMUXER 0 ++#define CONFIG_H263_DEMUXER 0 ++#define CONFIG_H264_DEMUXER 0 ++#define CONFIG_HEVC_DEMUXER 0 ++#define CONFIG_HLS_DEMUXER 0 ++#define CONFIG_HNM_DEMUXER 0 ++#define CONFIG_ICO_DEMUXER 0 ++#define CONFIG_IDCIN_DEMUXER 0 ++#define CONFIG_IDF_DEMUXER 0 ++#define CONFIG_IFF_DEMUXER 0 ++#define CONFIG_ILBC_DEMUXER 0 ++#define CONFIG_IMAGE2_DEMUXER 0 ++#define CONFIG_IMAGE2PIPE_DEMUXER 0 ++#define CONFIG_IMAGE2_ALIAS_PIX_DEMUXER 0 ++#define CONFIG_IMAGE2_BRENDER_PIX_DEMUXER 0 ++#define CONFIG_INGENIENT_DEMUXER 0 ++#define CONFIG_IPMOVIE_DEMUXER 0 ++#define CONFIG_IRCAM_DEMUXER 0 ++#define CONFIG_ISS_DEMUXER 0 ++#define CONFIG_IV8_DEMUXER 0 ++#define CONFIG_IVF_DEMUXER 0 ++#define CONFIG_IVR_DEMUXER 0 ++#define CONFIG_JACOSUB_DEMUXER 0 ++#define CONFIG_JV_DEMUXER 0 ++#define CONFIG_LMLM4_DEMUXER 0 ++#define CONFIG_LOAS_DEMUXER 0 ++#define CONFIG_LRC_DEMUXER 0 ++#define CONFIG_LVF_DEMUXER 0 ++#define CONFIG_LXF_DEMUXER 0 ++#define CONFIG_M4V_DEMUXER 0 ++#define CONFIG_MATROSKA_DEMUXER 1 ++#define CONFIG_MGSTS_DEMUXER 0 ++#define CONFIG_MICRODVD_DEMUXER 0 ++#define CONFIG_MJPEG_DEMUXER 0 ++#define CONFIG_MJPEG_2000_DEMUXER 0 ++#define CONFIG_MLP_DEMUXER 0 ++#define CONFIG_MLV_DEMUXER 0 ++#define CONFIG_MM_DEMUXER 0 ++#define CONFIG_MMF_DEMUXER 0 ++#define CONFIG_MOV_DEMUXER 1 ++#define CONFIG_MP3_DEMUXER 1 ++#define CONFIG_MPC_DEMUXER 0 ++#define CONFIG_MPC8_DEMUXER 0 ++#define CONFIG_MPEGPS_DEMUXER 0 ++#define CONFIG_MPEGTS_DEMUXER 0 ++#define CONFIG_MPEGTSRAW_DEMUXER 0 ++#define CONFIG_MPEGVIDEO_DEMUXER 0 ++#define CONFIG_MPJPEG_DEMUXER 0 ++#define CONFIG_MPL2_DEMUXER 0 ++#define CONFIG_MPSUB_DEMUXER 0 ++#define CONFIG_MSF_DEMUXER 0 ++#define CONFIG_MSNWC_TCP_DEMUXER 0 ++#define CONFIG_MTAF_DEMUXER 0 ++#define CONFIG_MTV_DEMUXER 0 ++#define CONFIG_MUSX_DEMUXER 0 ++#define CONFIG_MV_DEMUXER 0 ++#define CONFIG_MVI_DEMUXER 0 ++#define CONFIG_MXF_DEMUXER 0 ++#define CONFIG_MXG_DEMUXER 0 ++#define CONFIG_NC_DEMUXER 0 ++#define CONFIG_NISTSPHERE_DEMUXER 0 ++#define CONFIG_NSP_DEMUXER 0 ++#define CONFIG_NSV_DEMUXER 0 ++#define CONFIG_NUT_DEMUXER 0 ++#define CONFIG_NUV_DEMUXER 0 ++#define CONFIG_OGG_DEMUXER 1 ++#define CONFIG_OMA_DEMUXER 0 ++#define CONFIG_PAF_DEMUXER 0 ++#define CONFIG_PCM_ALAW_DEMUXER 0 ++#define CONFIG_PCM_MULAW_DEMUXER 0 ++#define CONFIG_PCM_VIDC_DEMUXER 0 ++#define CONFIG_PCM_F64BE_DEMUXER 0 ++#define CONFIG_PCM_F64LE_DEMUXER 0 ++#define CONFIG_PCM_F32BE_DEMUXER 0 ++#define CONFIG_PCM_F32LE_DEMUXER 0 ++#define CONFIG_PCM_S32BE_DEMUXER 0 ++#define CONFIG_PCM_S32LE_DEMUXER 0 ++#define CONFIG_PCM_S24BE_DEMUXER 0 ++#define CONFIG_PCM_S24LE_DEMUXER 0 ++#define CONFIG_PCM_S16BE_DEMUXER 0 ++#define CONFIG_PCM_S16LE_DEMUXER 0 ++#define CONFIG_PCM_S8_DEMUXER 0 ++#define CONFIG_PCM_U32BE_DEMUXER 0 ++#define CONFIG_PCM_U32LE_DEMUXER 0 ++#define CONFIG_PCM_U24BE_DEMUXER 0 ++#define CONFIG_PCM_U24LE_DEMUXER 0 ++#define CONFIG_PCM_U16BE_DEMUXER 0 ++#define CONFIG_PCM_U16LE_DEMUXER 0 ++#define CONFIG_PCM_U8_DEMUXER 0 ++#define CONFIG_PJS_DEMUXER 0 ++#define CONFIG_PMP_DEMUXER 0 ++#define CONFIG_PVA_DEMUXER 0 ++#define CONFIG_PVF_DEMUXER 0 ++#define CONFIG_QCP_DEMUXER 0 ++#define CONFIG_R3D_DEMUXER 0 ++#define CONFIG_RAWVIDEO_DEMUXER 0 ++#define CONFIG_REALTEXT_DEMUXER 0 ++#define CONFIG_REDSPARK_DEMUXER 0 ++#define CONFIG_RL2_DEMUXER 0 ++#define CONFIG_RM_DEMUXER 0 ++#define CONFIG_ROQ_DEMUXER 0 ++#define CONFIG_RPL_DEMUXER 0 ++#define CONFIG_RSD_DEMUXER 0 ++#define CONFIG_RSO_DEMUXER 0 ++#define CONFIG_RTP_DEMUXER 0 ++#define CONFIG_RTSP_DEMUXER 0 ++#define CONFIG_S337M_DEMUXER 0 ++#define CONFIG_SAMI_DEMUXER 0 ++#define CONFIG_SAP_DEMUXER 0 ++#define CONFIG_SBC_DEMUXER 0 ++#define CONFIG_SBG_DEMUXER 0 ++#define CONFIG_SCC_DEMUXER 0 ++#define CONFIG_SDP_DEMUXER 0 ++#define CONFIG_SDR2_DEMUXER 0 ++#define CONFIG_SDS_DEMUXER 0 ++#define CONFIG_SDX_DEMUXER 0 ++#define CONFIG_SEGAFILM_DEMUXER 0 ++#define CONFIG_SER_DEMUXER 0 ++#define CONFIG_SHORTEN_DEMUXER 0 ++#define CONFIG_SIFF_DEMUXER 0 ++#define CONFIG_SLN_DEMUXER 0 ++#define CONFIG_SMACKER_DEMUXER 0 ++#define CONFIG_SMJPEG_DEMUXER 0 ++#define CONFIG_SMUSH_DEMUXER 0 ++#define CONFIG_SOL_DEMUXER 0 ++#define CONFIG_SOX_DEMUXER 0 ++#define CONFIG_SPDIF_DEMUXER 0 ++#define CONFIG_SRT_DEMUXER 0 ++#define CONFIG_STR_DEMUXER 0 ++#define CONFIG_STL_DEMUXER 0 ++#define CONFIG_SUBVIEWER1_DEMUXER 0 ++#define CONFIG_SUBVIEWER_DEMUXER 0 ++#define CONFIG_SUP_DEMUXER 0 ++#define CONFIG_SVAG_DEMUXER 0 ++#define CONFIG_SWF_DEMUXER 0 ++#define CONFIG_TAK_DEMUXER 0 ++#define CONFIG_TEDCAPTIONS_DEMUXER 0 ++#define CONFIG_THP_DEMUXER 0 ++#define CONFIG_THREEDOSTR_DEMUXER 0 ++#define CONFIG_TIERTEXSEQ_DEMUXER 0 ++#define CONFIG_TMV_DEMUXER 0 ++#define CONFIG_TRUEHD_DEMUXER 0 ++#define CONFIG_TTA_DEMUXER 0 ++#define CONFIG_TXD_DEMUXER 0 ++#define CONFIG_TTY_DEMUXER 0 ++#define CONFIG_TY_DEMUXER 0 ++#define CONFIG_V210_DEMUXER 0 ++#define CONFIG_V210X_DEMUXER 0 ++#define CONFIG_VAG_DEMUXER 0 ++#define CONFIG_VC1_DEMUXER 0 ++#define CONFIG_VC1T_DEMUXER 0 ++#define CONFIG_VIVO_DEMUXER 0 ++#define CONFIG_VMD_DEMUXER 0 ++#define CONFIG_VOBSUB_DEMUXER 0 ++#define CONFIG_VOC_DEMUXER 0 ++#define CONFIG_VPK_DEMUXER 0 ++#define CONFIG_VPLAYER_DEMUXER 0 ++#define CONFIG_VQF_DEMUXER 0 ++#define CONFIG_W64_DEMUXER 0 ++#define CONFIG_WAV_DEMUXER 1 ++#define CONFIG_WC3_DEMUXER 0 ++#define CONFIG_WEBM_DASH_MANIFEST_DEMUXER 0 ++#define CONFIG_WEBVTT_DEMUXER 0 ++#define CONFIG_WSAUD_DEMUXER 0 ++#define CONFIG_WSD_DEMUXER 0 ++#define CONFIG_WSVQA_DEMUXER 0 ++#define CONFIG_WTV_DEMUXER 0 ++#define CONFIG_WVE_DEMUXER 0 ++#define CONFIG_WV_DEMUXER 0 ++#define CONFIG_XA_DEMUXER 0 ++#define CONFIG_XBIN_DEMUXER 0 ++#define CONFIG_XMV_DEMUXER 0 ++#define CONFIG_XVAG_DEMUXER 0 ++#define CONFIG_XWMA_DEMUXER 0 ++#define CONFIG_YOP_DEMUXER 0 ++#define CONFIG_YUV4MPEGPIPE_DEMUXER 0 ++#define CONFIG_IMAGE_BMP_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_DDS_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_DPX_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_EXR_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_J2K_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_JPEG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_JPEGLS_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PAM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PBM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PCX_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PGMYUV_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PGM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PICTOR_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PNG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PPM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PSD_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_QDRAW_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SGI_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SVG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SUNRAST_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_TIFF_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_WEBP_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_XPM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_XWD_PIPE_DEMUXER 0 ++#define CONFIG_LIBGME_DEMUXER 0 ++#define CONFIG_LIBMODPLUG_DEMUXER 0 ++#define CONFIG_LIBOPENMPT_DEMUXER 0 ++#define CONFIG_VAPOURSYNTH_DEMUXER 0 ++#define CONFIG_A64_MUXER 0 ++#define CONFIG_AC3_MUXER 0 ++#define CONFIG_ADTS_MUXER 0 ++#define CONFIG_ADX_MUXER 0 ++#define CONFIG_AIFF_MUXER 0 ++#define CONFIG_AMR_MUXER 0 ++#define CONFIG_APNG_MUXER 0 ++#define CONFIG_APTX_MUXER 0 ++#define CONFIG_APTX_HD_MUXER 0 ++#define CONFIG_ASF_MUXER 0 ++#define CONFIG_ASS_MUXER 0 ++#define CONFIG_AST_MUXER 0 ++#define CONFIG_ASF_STREAM_MUXER 0 ++#define CONFIG_AU_MUXER 0 ++#define CONFIG_AVI_MUXER 0 ++#define CONFIG_AVM2_MUXER 0 ++#define CONFIG_AVS2_MUXER 0 ++#define CONFIG_BIT_MUXER 0 ++#define CONFIG_CAF_MUXER 0 ++#define CONFIG_CAVSVIDEO_MUXER 0 ++#define CONFIG_CODEC2_MUXER 0 ++#define CONFIG_CODEC2RAW_MUXER 0 ++#define CONFIG_CRC_MUXER 0 ++#define CONFIG_DASH_MUXER 0 ++#define CONFIG_DATA_MUXER 0 ++#define CONFIG_DAUD_MUXER 0 ++#define CONFIG_DIRAC_MUXER 0 ++#define CONFIG_DNXHD_MUXER 0 ++#define CONFIG_DTS_MUXER 0 ++#define CONFIG_DV_MUXER 0 ++#define CONFIG_EAC3_MUXER 0 ++#define CONFIG_F4V_MUXER 0 ++#define CONFIG_FFMETADATA_MUXER 0 ++#define CONFIG_FIFO_MUXER 0 ++#define CONFIG_FIFO_TEST_MUXER 0 ++#define CONFIG_FILMSTRIP_MUXER 0 ++#define CONFIG_FITS_MUXER 0 ++#define CONFIG_FLAC_MUXER 0 ++#define CONFIG_FLV_MUXER 0 ++#define CONFIG_FRAMECRC_MUXER 0 ++#define CONFIG_FRAMEHASH_MUXER 0 ++#define CONFIG_FRAMEMD5_MUXER 0 ++#define CONFIG_G722_MUXER 0 ++#define CONFIG_G723_1_MUXER 0 ++#define CONFIG_G726_MUXER 0 ++#define CONFIG_G726LE_MUXER 0 ++#define CONFIG_GIF_MUXER 0 ++#define CONFIG_GSM_MUXER 0 ++#define CONFIG_GXF_MUXER 0 ++#define CONFIG_H261_MUXER 0 ++#define CONFIG_H263_MUXER 0 ++#define CONFIG_H264_MUXER 0 ++#define CONFIG_HASH_MUXER 0 ++#define CONFIG_HDS_MUXER 0 ++#define CONFIG_HEVC_MUXER 0 ++#define CONFIG_HLS_MUXER 0 ++#define CONFIG_ICO_MUXER 0 ++#define CONFIG_ILBC_MUXER 0 ++#define CONFIG_IMAGE2_MUXER 0 ++#define CONFIG_IMAGE2PIPE_MUXER 0 ++#define CONFIG_IPOD_MUXER 0 ++#define CONFIG_IRCAM_MUXER 0 ++#define CONFIG_ISMV_MUXER 0 ++#define CONFIG_IVF_MUXER 0 ++#define CONFIG_JACOSUB_MUXER 0 ++#define CONFIG_LATM_MUXER 0 ++#define CONFIG_LRC_MUXER 0 ++#define CONFIG_M4V_MUXER 0 ++#define CONFIG_MD5_MUXER 0 ++#define CONFIG_MATROSKA_MUXER 0 ++#define CONFIG_MATROSKA_AUDIO_MUXER 0 ++#define CONFIG_MICRODVD_MUXER 0 ++#define CONFIG_MJPEG_MUXER 0 ++#define CONFIG_MLP_MUXER 0 ++#define CONFIG_MMF_MUXER 0 ++#define CONFIG_MOV_MUXER 0 ++#define CONFIG_MP2_MUXER 0 ++#define CONFIG_MP3_MUXER 0 ++#define CONFIG_MP4_MUXER 0 ++#define CONFIG_MPEG1SYSTEM_MUXER 0 ++#define CONFIG_MPEG1VCD_MUXER 0 ++#define CONFIG_MPEG1VIDEO_MUXER 0 ++#define CONFIG_MPEG2DVD_MUXER 0 ++#define CONFIG_MPEG2SVCD_MUXER 0 ++#define CONFIG_MPEG2VIDEO_MUXER 0 ++#define CONFIG_MPEG2VOB_MUXER 0 ++#define CONFIG_MPEGTS_MUXER 0 ++#define CONFIG_MPJPEG_MUXER 0 ++#define CONFIG_MXF_MUXER 0 ++#define CONFIG_MXF_D10_MUXER 0 ++#define CONFIG_MXF_OPATOM_MUXER 0 ++#define CONFIG_NULL_MUXER 0 ++#define CONFIG_NUT_MUXER 0 ++#define CONFIG_OGA_MUXER 0 ++#define CONFIG_OGG_MUXER 0 ++#define CONFIG_OGV_MUXER 0 ++#define CONFIG_OMA_MUXER 0 ++#define CONFIG_OPUS_MUXER 0 ++#define CONFIG_PCM_ALAW_MUXER 0 ++#define CONFIG_PCM_MULAW_MUXER 0 ++#define CONFIG_PCM_VIDC_MUXER 0 ++#define CONFIG_PCM_F64BE_MUXER 0 ++#define CONFIG_PCM_F64LE_MUXER 0 ++#define CONFIG_PCM_F32BE_MUXER 0 ++#define CONFIG_PCM_F32LE_MUXER 0 ++#define CONFIG_PCM_S32BE_MUXER 0 ++#define CONFIG_PCM_S32LE_MUXER 0 ++#define CONFIG_PCM_S24BE_MUXER 0 ++#define CONFIG_PCM_S24LE_MUXER 0 ++#define CONFIG_PCM_S16BE_MUXER 0 ++#define CONFIG_PCM_S16LE_MUXER 0 ++#define CONFIG_PCM_S8_MUXER 0 ++#define CONFIG_PCM_U32BE_MUXER 0 ++#define CONFIG_PCM_U32LE_MUXER 0 ++#define CONFIG_PCM_U24BE_MUXER 0 ++#define CONFIG_PCM_U24LE_MUXER 0 ++#define CONFIG_PCM_U16BE_MUXER 0 ++#define CONFIG_PCM_U16LE_MUXER 0 ++#define CONFIG_PCM_U8_MUXER 0 ++#define CONFIG_PSP_MUXER 0 ++#define CONFIG_RAWVIDEO_MUXER 0 ++#define CONFIG_RM_MUXER 0 ++#define CONFIG_ROQ_MUXER 0 ++#define CONFIG_RSO_MUXER 0 ++#define CONFIG_RTP_MUXER 0 ++#define CONFIG_RTP_MPEGTS_MUXER 0 ++#define CONFIG_RTSP_MUXER 0 ++#define CONFIG_SAP_MUXER 0 ++#define CONFIG_SBC_MUXER 0 ++#define CONFIG_SCC_MUXER 0 ++#define CONFIG_SEGAFILM_MUXER 0 ++#define CONFIG_SEGMENT_MUXER 0 ++#define CONFIG_STREAM_SEGMENT_MUXER 0 ++#define CONFIG_SINGLEJPEG_MUXER 0 ++#define CONFIG_SMJPEG_MUXER 0 ++#define CONFIG_SMOOTHSTREAMING_MUXER 0 ++#define CONFIG_SOX_MUXER 0 ++#define CONFIG_SPX_MUXER 0 ++#define CONFIG_SPDIF_MUXER 0 ++#define CONFIG_SRT_MUXER 0 ++#define CONFIG_SUP_MUXER 0 ++#define CONFIG_SWF_MUXER 0 ++#define CONFIG_TEE_MUXER 0 ++#define CONFIG_TG2_MUXER 0 ++#define CONFIG_TGP_MUXER 0 ++#define CONFIG_MKVTIMESTAMP_V2_MUXER 0 ++#define CONFIG_TRUEHD_MUXER 0 ++#define CONFIG_TTA_MUXER 0 ++#define CONFIG_UNCODEDFRAMECRC_MUXER 0 ++#define CONFIG_VC1_MUXER 0 ++#define CONFIG_VC1T_MUXER 0 ++#define CONFIG_VOC_MUXER 0 ++#define CONFIG_W64_MUXER 0 ++#define CONFIG_WAV_MUXER 0 ++#define CONFIG_WEBM_MUXER 0 ++#define CONFIG_WEBM_DASH_MANIFEST_MUXER 0 ++#define CONFIG_WEBM_CHUNK_MUXER 0 ++#define CONFIG_WEBP_MUXER 0 ++#define CONFIG_WEBVTT_MUXER 0 ++#define CONFIG_WTV_MUXER 0 ++#define CONFIG_WV_MUXER 0 ++#define CONFIG_YUV4MPEGPIPE_MUXER 0 ++#define CONFIG_CHROMAPRINT_MUXER 0 ++#define CONFIG_ASYNC_PROTOCOL 0 ++#define CONFIG_BLURAY_PROTOCOL 0 ++#define CONFIG_CACHE_PROTOCOL 0 ++#define CONFIG_CONCAT_PROTOCOL 0 ++#define CONFIG_CRYPTO_PROTOCOL 0 ++#define CONFIG_DATA_PROTOCOL 0 ++#define CONFIG_FFRTMPCRYPT_PROTOCOL 0 ++#define CONFIG_FFRTMPHTTP_PROTOCOL 0 ++#define CONFIG_FILE_PROTOCOL 0 ++#define CONFIG_FTP_PROTOCOL 0 ++#define CONFIG_GOPHER_PROTOCOL 0 ++#define CONFIG_HLS_PROTOCOL 0 ++#define CONFIG_HTTP_PROTOCOL 0 ++#define CONFIG_HTTPPROXY_PROTOCOL 0 ++#define CONFIG_HTTPS_PROTOCOL 0 ++#define CONFIG_ICECAST_PROTOCOL 0 ++#define CONFIG_MMSH_PROTOCOL 0 ++#define CONFIG_MMST_PROTOCOL 0 ++#define CONFIG_MD5_PROTOCOL 0 ++#define CONFIG_PIPE_PROTOCOL 0 ++#define CONFIG_PROMPEG_PROTOCOL 0 ++#define CONFIG_RTMP_PROTOCOL 0 ++#define CONFIG_RTMPE_PROTOCOL 0 ++#define CONFIG_RTMPS_PROTOCOL 0 ++#define CONFIG_RTMPT_PROTOCOL 0 ++#define CONFIG_RTMPTE_PROTOCOL 0 ++#define CONFIG_RTMPTS_PROTOCOL 0 ++#define CONFIG_RTP_PROTOCOL 0 ++#define CONFIG_SCTP_PROTOCOL 0 ++#define CONFIG_SRTP_PROTOCOL 0 ++#define CONFIG_SUBFILE_PROTOCOL 0 ++#define CONFIG_TEE_PROTOCOL 0 ++#define CONFIG_TCP_PROTOCOL 0 ++#define CONFIG_TLS_PROTOCOL 0 ++#define CONFIG_UDP_PROTOCOL 0 ++#define CONFIG_UDPLITE_PROTOCOL 0 ++#define CONFIG_UNIX_PROTOCOL 0 ++#define CONFIG_LIBRTMP_PROTOCOL 0 ++#define CONFIG_LIBRTMPE_PROTOCOL 0 ++#define CONFIG_LIBRTMPS_PROTOCOL 0 ++#define CONFIG_LIBRTMPT_PROTOCOL 0 ++#define CONFIG_LIBRTMPTE_PROTOCOL 0 ++#define CONFIG_LIBSRT_PROTOCOL 0 ++#define CONFIG_LIBSSH_PROTOCOL 0 ++#define CONFIG_LIBSMBCLIENT_PROTOCOL 0 ++#endif /* FFMPEG_CONFIG_H */ +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/bsf_list.c b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/bsf_list.c +new file mode 100644 +index 00000000000..d31ece942a7 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/bsf_list.c +@@ -0,0 +1,3 @@ ++static const AVBitStreamFilter * const bitstream_filters[] = { ++ &ff_null_bsf, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/codec_list.c b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/codec_list.c +new file mode 100644 +index 00000000000..49f757b2d86 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/codec_list.c +@@ -0,0 +1,20 @@ ++static const AVCodec * const codec_list[] = { ++ &ff_h264_decoder, ++ &ff_theora_decoder, ++ &ff_vp3_decoder, ++ &ff_vp8_decoder, ++ &ff_aac_decoder, ++ &ff_flac_decoder, ++ &ff_mp3_decoder, ++ &ff_vorbis_decoder, ++ &ff_pcm_alaw_decoder, ++ &ff_pcm_f32le_decoder, ++ &ff_pcm_mulaw_decoder, ++ &ff_pcm_s16be_decoder, ++ &ff_pcm_s16le_decoder, ++ &ff_pcm_s24be_decoder, ++ &ff_pcm_s24le_decoder, ++ &ff_pcm_s32le_decoder, ++ &ff_pcm_u8_decoder, ++ &ff_libopus_decoder, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/parser_list.c b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/parser_list.c +new file mode 100644 +index 00000000000..19d670aa24b +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavcodec/parser_list.c +@@ -0,0 +1,10 @@ ++static const AVCodecParser * const parser_list[] = { ++ &ff_aac_parser, ++ &ff_flac_parser, ++ &ff_h264_parser, ++ &ff_mpegaudio_parser, ++ &ff_opus_parser, ++ &ff_vorbis_parser, ++ &ff_vp3_parser, ++ &ff_vp8_parser, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/demuxer_list.c b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/demuxer_list.c +new file mode 100644 +index 00000000000..920b22bfa7d +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/demuxer_list.c +@@ -0,0 +1,9 @@ ++static const AVInputFormat * const demuxer_list[] = { ++ &ff_aac_demuxer, ++ &ff_flac_demuxer, ++ &ff_matroska_demuxer, ++ &ff_mov_demuxer, ++ &ff_mp3_demuxer, ++ &ff_ogg_demuxer, ++ &ff_wav_demuxer, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/muxer_list.c b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/muxer_list.c +new file mode 100644 +index 00000000000..f36d9499c6f +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/muxer_list.c +@@ -0,0 +1,2 @@ ++static const AVOutputFormat * const muxer_list[] = { ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/protocol_list.c b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/protocol_list.c +new file mode 100644 +index 00000000000..247e1e4c3a2 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavformat/protocol_list.c +@@ -0,0 +1,2 @@ ++static const URLProtocol * const url_protocols[] = { ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavutil/avconfig.h b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavutil/avconfig.h +new file mode 100644 +index 00000000000..c289fbb551c +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavutil/avconfig.h +@@ -0,0 +1,6 @@ ++/* Generated by ffmpeg configure */ ++#ifndef AVUTIL_AVCONFIG_H ++#define AVUTIL_AVCONFIG_H ++#define AV_HAVE_BIGENDIAN 0 ++#define AV_HAVE_FAST_UNALIGNED 1 ++#endif /* AVUTIL_AVCONFIG_H */ +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavutil/ffversion.h b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavutil/ffversion.h +new file mode 100644 +index 00000000000..9d3dbe8cc2a +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chrome/linux/ppc64/libavutil/ffversion.h +@@ -0,0 +1,5 @@ ++/* Automatically generated by version.sh, do not manually edit! */ ++#ifndef AVUTIL_FFVERSION_H ++#define AVUTIL_FFVERSION_H ++#define FFMPEG_VERSION "git-2020-01-07-ccf3ef182a0" ++#endif /* AVUTIL_FFVERSION_H */ +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/config.h b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/config.h +new file mode 100644 +index 00000000000..ac48bdfebc5 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/config.h +@@ -0,0 +1,2478 @@ ++/* Automatically generated by configure - do not modify! */ ++#ifndef FFMPEG_CONFIG_H ++#define FFMPEG_CONFIG_H ++/* #define FFMPEG_CONFIGURATION "--disable-everything --disable-all --disable-doc --disable-htmlpages --disable-manpages --disable-podpages --disable-txtpages --disable-static --enable-avcodec --enable-avformat --enable-avutil --enable-fft --enable-rdft --enable-static --enable-libopus --disable-debug --disable-bzlib --disable-iconv --disable-lzo --disable-network --disable-schannel --disable-sdl2 --disable-symver --disable-xlib --disable-zlib --disable-securetransport --disable-faan --disable-alsa --disable-autodetect --enable-decoder='vorbis,libopus,flac' --enable-decoder='pcm_u8,pcm_s16le,pcm_s24le,pcm_s32le,pcm_f32le,mp3' --enable-decoder='pcm_s16be,pcm_s24be,pcm_mulaw,pcm_alaw' --enable-demuxer='ogg,matroska,wav,flac,mp3,mov' --enable-parser='opus,vorbis,flac,mpegaudio' --extra-cflags=-I/mnt/dan/qtwebengine/src/3rdparty/chromium/third_party/opus/src/include --disable-linux-perf --x86asmexe=nasm --optflags='\"-O2\"' --enable-decoder='theora,vp8' --enable-parser='vp3,vp8' --arch=ppc64le --extra-cflags='-mcpu=power9' --enable-pic --cc=clang --cxx=clang++ --ld=clang --enable-decoder='aac,h264' --enable-demuxer=aac --enable-parser='aac,h264' --enable-decoder=mpeg4 --enable-parser='h263,mpeg4video' --enable-demuxer=avi --enable-demuxer=amr --enable-decoder='amrnb,amrwb' --enable-decoder=gsm_ms --enable-parser=gsm" -- elide long configuration string from binary */ ++#define FFMPEG_LICENSE "LGPL version 2.1 or later" ++#define CONFIG_THIS_YEAR 2018 ++#define FFMPEG_DATADIR "/usr/local/share/ffmpeg" ++#define AVCONV_DATADIR "/usr/local/share/ffmpeg" ++#define CC_IDENT "clang version 8.0.0 (Fedora 8.0.0-3.fc30)" ++#define av_restrict restrict ++#define EXTERN_PREFIX "" ++#define EXTERN_ASM ++#define BUILDSUF "" ++#define SLIBSUF ".so" ++#define HAVE_MMX2 HAVE_MMXEXT ++#define SWS_MAX_FILTER_SIZE 256 ++#define ARCH_AARCH64 0 ++#define ARCH_ALPHA 0 ++#define ARCH_ARM 0 ++#define ARCH_AVR32 0 ++#define ARCH_AVR32_AP 0 ++#define ARCH_AVR32_UC 0 ++#define ARCH_BFIN 0 ++#define ARCH_IA64 0 ++#define ARCH_M68K 0 ++#define ARCH_MIPS 0 ++#define ARCH_MIPS64 0 ++#define ARCH_PARISC 0 ++#define ARCH_PPC 1 ++#define ARCH_PPC64 1 ++#define ARCH_S390 0 ++#define ARCH_SH4 0 ++#define ARCH_SPARC 0 ++#define ARCH_SPARC64 0 ++#define ARCH_TILEGX 0 ++#define ARCH_TILEPRO 0 ++#define ARCH_TOMI 0 ++#define ARCH_X86 0 ++#define ARCH_X86_32 0 ++#define ARCH_X86_64 0 ++#define HAVE_ARMV5TE 0 ++#define HAVE_ARMV6 0 ++#define HAVE_ARMV6T2 0 ++#define HAVE_ARMV8 0 ++#define HAVE_NEON 0 ++#define HAVE_VFP 0 ++#define HAVE_VFPV3 0 ++#define HAVE_SETEND 0 ++#define HAVE_ALTIVEC 1 ++#define HAVE_DCBZL 1 ++#define HAVE_LDBRX 0 ++#define HAVE_POWER8 1 ++#define HAVE_PPC4XX 0 ++#define HAVE_VSX 1 ++#define HAVE_AESNI 0 ++#define HAVE_AMD3DNOW 0 ++#define HAVE_AMD3DNOWEXT 0 ++#define HAVE_AVX 0 ++#define HAVE_AVX2 0 ++#define HAVE_AVX512 0 ++#define HAVE_FMA3 0 ++#define HAVE_FMA4 0 ++#define HAVE_MMX 0 ++#define HAVE_MMXEXT 0 ++#define HAVE_SSE 0 ++#define HAVE_SSE2 0 ++#define HAVE_SSE3 0 ++#define HAVE_SSE4 0 ++#define HAVE_SSE42 0 ++#define HAVE_SSSE3 0 ++#define HAVE_XOP 0 ++#define HAVE_CPUNOP 0 ++#define HAVE_I686 0 ++#define HAVE_MIPSFPU 0 ++#define HAVE_MIPS32R2 0 ++#define HAVE_MIPS32R5 0 ++#define HAVE_MIPS64R2 0 ++#define HAVE_MIPS32R6 0 ++#define HAVE_MIPS64R6 0 ++#define HAVE_MIPSDSP 0 ++#define HAVE_MIPSDSPR2 0 ++#define HAVE_MSA 0 ++#define HAVE_LOONGSON2 0 ++#define HAVE_LOONGSON3 0 ++#define HAVE_MMI 0 ++#define HAVE_ARMV5TE_EXTERNAL 0 ++#define HAVE_ARMV6_EXTERNAL 0 ++#define HAVE_ARMV6T2_EXTERNAL 0 ++#define HAVE_ARMV8_EXTERNAL 0 ++#define HAVE_NEON_EXTERNAL 0 ++#define HAVE_VFP_EXTERNAL 0 ++#define HAVE_VFPV3_EXTERNAL 0 ++#define HAVE_SETEND_EXTERNAL 0 ++#define HAVE_ALTIVEC_EXTERNAL 0 ++#define HAVE_DCBZL_EXTERNAL 0 ++#define HAVE_LDBRX_EXTERNAL 0 ++#define HAVE_POWER8_EXTERNAL 0 ++#define HAVE_PPC4XX_EXTERNAL 0 ++#define HAVE_VSX_EXTERNAL 0 ++#define HAVE_AESNI_EXTERNAL 0 ++#define HAVE_AMD3DNOW_EXTERNAL 0 ++#define HAVE_AMD3DNOWEXT_EXTERNAL 0 ++#define HAVE_AVX_EXTERNAL 0 ++#define HAVE_AVX2_EXTERNAL 0 ++#define HAVE_AVX512_EXTERNAL 0 ++#define HAVE_FMA3_EXTERNAL 0 ++#define HAVE_FMA4_EXTERNAL 0 ++#define HAVE_MMX_EXTERNAL 0 ++#define HAVE_MMXEXT_EXTERNAL 0 ++#define HAVE_SSE_EXTERNAL 0 ++#define HAVE_SSE2_EXTERNAL 0 ++#define HAVE_SSE3_EXTERNAL 0 ++#define HAVE_SSE4_EXTERNAL 0 ++#define HAVE_SSE42_EXTERNAL 0 ++#define HAVE_SSSE3_EXTERNAL 0 ++#define HAVE_XOP_EXTERNAL 0 ++#define HAVE_CPUNOP_EXTERNAL 0 ++#define HAVE_I686_EXTERNAL 0 ++#define HAVE_MIPSFPU_EXTERNAL 0 ++#define HAVE_MIPS32R2_EXTERNAL 0 ++#define HAVE_MIPS32R5_EXTERNAL 0 ++#define HAVE_MIPS64R2_EXTERNAL 0 ++#define HAVE_MIPS32R6_EXTERNAL 0 ++#define HAVE_MIPS64R6_EXTERNAL 0 ++#define HAVE_MIPSDSP_EXTERNAL 0 ++#define HAVE_MIPSDSPR2_EXTERNAL 0 ++#define HAVE_MSA_EXTERNAL 0 ++#define HAVE_LOONGSON2_EXTERNAL 0 ++#define HAVE_LOONGSON3_EXTERNAL 0 ++#define HAVE_MMI_EXTERNAL 0 ++#define HAVE_ARMV5TE_INLINE 0 ++#define HAVE_ARMV6_INLINE 0 ++#define HAVE_ARMV6T2_INLINE 0 ++#define HAVE_ARMV8_INLINE 0 ++#define HAVE_NEON_INLINE 0 ++#define HAVE_VFP_INLINE 0 ++#define HAVE_VFPV3_INLINE 0 ++#define HAVE_SETEND_INLINE 0 ++#define HAVE_ALTIVEC_INLINE 0 ++#define HAVE_DCBZL_INLINE 0 ++#define HAVE_LDBRX_INLINE 0 ++#define HAVE_POWER8_INLINE 0 ++#define HAVE_PPC4XX_INLINE 0 ++#define HAVE_VSX_INLINE 0 ++#define HAVE_AESNI_INLINE 0 ++#define HAVE_AMD3DNOW_INLINE 0 ++#define HAVE_AMD3DNOWEXT_INLINE 0 ++#define HAVE_AVX_INLINE 0 ++#define HAVE_AVX2_INLINE 0 ++#define HAVE_AVX512_INLINE 0 ++#define HAVE_FMA3_INLINE 0 ++#define HAVE_FMA4_INLINE 0 ++#define HAVE_MMX_INLINE 0 ++#define HAVE_MMXEXT_INLINE 0 ++#define HAVE_SSE_INLINE 0 ++#define HAVE_SSE2_INLINE 0 ++#define HAVE_SSE3_INLINE 0 ++#define HAVE_SSE4_INLINE 0 ++#define HAVE_SSE42_INLINE 0 ++#define HAVE_SSSE3_INLINE 0 ++#define HAVE_XOP_INLINE 0 ++#define HAVE_CPUNOP_INLINE 0 ++#define HAVE_I686_INLINE 0 ++#define HAVE_MIPSFPU_INLINE 0 ++#define HAVE_MIPS32R2_INLINE 0 ++#define HAVE_MIPS32R5_INLINE 0 ++#define HAVE_MIPS64R2_INLINE 0 ++#define HAVE_MIPS32R6_INLINE 0 ++#define HAVE_MIPS64R6_INLINE 0 ++#define HAVE_MIPSDSP_INLINE 0 ++#define HAVE_MIPSDSPR2_INLINE 0 ++#define HAVE_MSA_INLINE 0 ++#define HAVE_LOONGSON2_INLINE 0 ++#define HAVE_LOONGSON3_INLINE 0 ++#define HAVE_MMI_INLINE 0 ++#define HAVE_ALIGNED_STACK 1 ++#define HAVE_FAST_64BIT 1 ++#define HAVE_FAST_CLZ 1 ++#define HAVE_FAST_CMOV 0 ++#define HAVE_LOCAL_ALIGNED 1 ++#define HAVE_SIMD_ALIGN_16 1 ++#define HAVE_SIMD_ALIGN_32 0 ++#define HAVE_SIMD_ALIGN_64 0 ++#define HAVE_ATOMIC_CAS_PTR 0 ++#define HAVE_MACHINE_RW_BARRIER 0 ++#define HAVE_MEMORYBARRIER 0 ++#define HAVE_MM_EMPTY 0 ++#define HAVE_RDTSC 0 ++#define HAVE_SEM_TIMEDWAIT 1 ++#define HAVE_SYNC_VAL_COMPARE_AND_SWAP 1 ++#define HAVE_CABS 0 ++#define HAVE_CEXP 0 ++#define HAVE_INLINE_ASM 1 ++#define HAVE_SYMVER 0 ++#define HAVE_X86ASM 0 ++#define HAVE_BIGENDIAN 0 ++#define HAVE_FAST_UNALIGNED 1 ++#define HAVE_ARPA_INET_H 0 ++#define HAVE_ASM_TYPES_H 1 ++#define HAVE_CDIO_PARANOIA_H 0 ++#define HAVE_CDIO_PARANOIA_PARANOIA_H 0 ++#define HAVE_CUDA_H 0 ++#define HAVE_DISPATCH_DISPATCH_H 0 ++#define HAVE_DEV_BKTR_IOCTL_BT848_H 0 ++#define HAVE_DEV_BKTR_IOCTL_METEOR_H 0 ++#define HAVE_DEV_IC_BT8XX_H 0 ++#define HAVE_DEV_VIDEO_BKTR_IOCTL_BT848_H 0 ++#define HAVE_DEV_VIDEO_METEOR_IOCTL_METEOR_H 0 ++#define HAVE_DIRECT_H 0 ++#define HAVE_DIRENT_H 1 ++#define HAVE_DXGIDEBUG_H 0 ++#define HAVE_DXVA_H 0 ++#define HAVE_ES2_GL_H 0 ++#define HAVE_GSM_H 0 ++#define HAVE_IO_H 0 ++#define HAVE_LINUX_PERF_EVENT_H 1 ++#define HAVE_MACHINE_IOCTL_BT848_H 0 ++#define HAVE_MACHINE_IOCTL_METEOR_H 0 ++#define HAVE_MALLOC_H 1 ++#define HAVE_OPENCV2_CORE_CORE_C_H 0 ++#define HAVE_OPENGL_GL3_H 0 ++#define HAVE_POLL_H 1 ++#define HAVE_SYS_PARAM_H 1 ++#define HAVE_SYS_RESOURCE_H 1 ++#define HAVE_SYS_SELECT_H 1 ++#define HAVE_SYS_SOUNDCARD_H 1 ++#define HAVE_SYS_TIME_H 1 ++#define HAVE_SYS_UN_H 1 ++#define HAVE_SYS_VIDEOIO_H 0 ++#define HAVE_TERMIOS_H 1 ++#define HAVE_UDPLITE_H 0 ++#define HAVE_UNISTD_H 1 ++#define HAVE_VALGRIND_VALGRIND_H 0 /* #define HAVE_VALGRIND_VALGRIND_H 1 -- forced to 0. See https://crbug.com/590440 */ ++#define HAVE_WINDOWS_H 0 ++#define HAVE_WINSOCK2_H 0 ++#define HAVE_INTRINSICS_NEON 0 ++#define HAVE_ATANF 1 ++#define HAVE_ATAN2F 1 ++#define HAVE_CBRT 1 ++#define HAVE_CBRTF 1 ++#define HAVE_COPYSIGN 1 ++#define HAVE_COSF 1 ++#define HAVE_ERF 1 ++#define HAVE_EXP2 1 ++#define HAVE_EXP2F 1 ++#define HAVE_EXPF 1 ++#define HAVE_HYPOT 1 ++#define HAVE_ISFINITE 1 ++#define HAVE_ISINF 1 ++#define HAVE_ISNAN 1 ++#define HAVE_LDEXPF 1 ++#define HAVE_LLRINT 1 ++#define HAVE_LLRINTF 1 ++#define HAVE_LOG2 1 ++#define HAVE_LOG2F 1 ++#define HAVE_LOG10F 1 ++#define HAVE_LRINT 1 ++#define HAVE_LRINTF 1 ++#define HAVE_POWF 1 ++#define HAVE_RINT 1 ++#define HAVE_ROUND 1 ++#define HAVE_ROUNDF 1 ++#define HAVE_SINF 1 ++#define HAVE_TRUNC 1 ++#define HAVE_TRUNCF 1 ++#define HAVE_DOS_PATHS 0 ++#define HAVE_LIBC_MSVCRT 0 ++#define HAVE_MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS 0 ++#define HAVE_SECTION_DATA_REL_RO 1 ++#define HAVE_THREADS 1 ++#define HAVE_UWP 0 ++#define HAVE_WINRT 0 ++#define HAVE_ACCESS 1 ++#define HAVE_ALIGNED_MALLOC 0 ++#define HAVE_ARC4RANDOM 0 ++#define HAVE_CLOCK_GETTIME 1 ++#define HAVE_CLOSESOCKET 0 ++#define HAVE_COMMANDLINETOARGVW 0 ++#define HAVE_FCNTL 1 ++#define HAVE_GETADDRINFO 0 ++#define HAVE_GETHRTIME 0 ++#define HAVE_GETOPT 1 ++#define HAVE_GETPROCESSAFFINITYMASK 0 ++#define HAVE_GETPROCESSMEMORYINFO 0 ++#define HAVE_GETPROCESSTIMES 0 ++#define HAVE_GETRUSAGE 1 ++#define HAVE_GETSYSTEMTIMEASFILETIME 0 ++#define HAVE_GETTIMEOFDAY 1 ++#define HAVE_GLOB 1 ++#define HAVE_GLXGETPROCADDRESS 0 ++#define HAVE_GMTIME_R 1 ++#define HAVE_INET_ATON 0 ++#define HAVE_ISATTY 1 ++#define HAVE_KBHIT 0 ++#define HAVE_LOCALTIME_R 1 ++#define HAVE_LSTAT 1 ++#define HAVE_LZO1X_999_COMPRESS 0 ++#define HAVE_MACH_ABSOLUTE_TIME 0 ++#define HAVE_MAPVIEWOFFILE 0 ++#define HAVE_MEMALIGN 1 ++#define HAVE_MKSTEMP 1 ++#define HAVE_MMAP 1 ++#define HAVE_MPROTECT 1 ++#define HAVE_NANOSLEEP 1 ++#define HAVE_PEEKNAMEDPIPE 0 ++#define HAVE_POSIX_MEMALIGN 1 ++#define HAVE_PTHREAD_CANCEL 1 ++#define HAVE_SCHED_GETAFFINITY 1 ++#define HAVE_SECITEMIMPORT 0 ++#define HAVE_SETCONSOLETEXTATTRIBUTE 0 ++#define HAVE_SETCONSOLECTRLHANDLER 0 ++#define HAVE_SETMODE 0 ++#define HAVE_SETRLIMIT 1 ++#define HAVE_SLEEP 0 ++#define HAVE_STRERROR_R 1 ++#define HAVE_SYSCONF 1 ++#define HAVE_SYSCTL 0 /* #define HAVE_SYSCTL 1 -- forced to 0 for Fuchsia */ ++#define HAVE_USLEEP 1 ++#define HAVE_UTGETOSTYPEFROMSTRING 0 ++#define HAVE_VIRTUALALLOC 0 ++#define HAVE_WGLGETPROCADDRESS 0 ++#define HAVE_BCRYPT 0 ++#define HAVE_VAAPI_DRM 0 ++#define HAVE_VAAPI_X11 0 ++#define HAVE_VDPAU_X11 0 ++#define HAVE_PTHREADS 1 ++#define HAVE_OS2THREADS 0 ++#define HAVE_W32THREADS 0 ++#define HAVE_AS_ARCH_DIRECTIVE 0 ++#define HAVE_AS_DN_DIRECTIVE 0 ++#define HAVE_AS_FPU_DIRECTIVE 0 ++#define HAVE_AS_FUNC 0 ++#define HAVE_AS_OBJECT_ARCH 0 ++#define HAVE_ASM_MOD_Q 0 ++#define HAVE_BLOCKS_EXTENSION 0 ++#define HAVE_EBP_AVAILABLE 0 ++#define HAVE_EBX_AVAILABLE 0 ++#define HAVE_GNU_AS 0 ++#define HAVE_GNU_WINDRES 0 ++#define HAVE_IBM_ASM 1 ++#define HAVE_INLINE_ASM_DIRECT_SYMBOL_REFS 0 ++#define HAVE_INLINE_ASM_LABELS 1 ++#define HAVE_INLINE_ASM_NONLOCAL_LABELS 1 ++#define HAVE_PRAGMA_DEPRECATED 1 ++#define HAVE_RSYNC_CONTIMEOUT 1 ++#define HAVE_SYMVER_ASM_LABEL 1 ++#define HAVE_SYMVER_GNU_ASM 1 ++#define HAVE_VFP_ARGS 0 ++#define HAVE_XFORM_ASM 1 ++#define HAVE_XMM_CLOBBERS 0 ++#define HAVE_KCMVIDEOCODECTYPE_HEVC 0 ++#define HAVE_SOCKLEN_T 0 ++#define HAVE_STRUCT_ADDRINFO 0 ++#define HAVE_STRUCT_GROUP_SOURCE_REQ 0 ++#define HAVE_STRUCT_IP_MREQ_SOURCE 0 ++#define HAVE_STRUCT_IPV6_MREQ 0 ++#define HAVE_STRUCT_MSGHDR_MSG_FLAGS 0 ++#define HAVE_STRUCT_POLLFD 0 ++#define HAVE_STRUCT_RUSAGE_RU_MAXRSS 1 ++#define HAVE_STRUCT_SCTP_EVENT_SUBSCRIBE 0 ++#define HAVE_STRUCT_SOCKADDR_IN6 0 ++#define HAVE_STRUCT_SOCKADDR_SA_LEN 0 ++#define HAVE_STRUCT_SOCKADDR_STORAGE 0 ++#define HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 1 ++#define HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE 0 ++#define HAVE_MAKEINFO 1 ++#define HAVE_MAKEINFO_HTML 1 ++#define HAVE_OPENCL_D3D11 0 ++#define HAVE_OPENCL_DRM_ARM 0 ++#define HAVE_OPENCL_DRM_BEIGNET 0 ++#define HAVE_OPENCL_DXVA2 0 ++#define HAVE_OPENCL_VAAPI_BEIGNET 0 ++#define HAVE_OPENCL_VAAPI_INTEL_MEDIA 0 ++#define HAVE_PERL 1 ++#define HAVE_POD2MAN 1 ++#define HAVE_TEXI2HTML 0 ++#define CONFIG_DOC 0 ++#define CONFIG_HTMLPAGES 0 ++#define CONFIG_MANPAGES 0 ++#define CONFIG_PODPAGES 0 ++#define CONFIG_TXTPAGES 0 ++#define CONFIG_AVIO_DIR_CMD_EXAMPLE 1 ++#define CONFIG_AVIO_READING_EXAMPLE 1 ++#define CONFIG_DECODE_AUDIO_EXAMPLE 1 ++#define CONFIG_DECODE_VIDEO_EXAMPLE 1 ++#define CONFIG_DEMUXING_DECODING_EXAMPLE 1 ++#define CONFIG_ENCODE_AUDIO_EXAMPLE 1 ++#define CONFIG_ENCODE_VIDEO_EXAMPLE 1 ++#define CONFIG_EXTRACT_MVS_EXAMPLE 1 ++#define CONFIG_FILTER_AUDIO_EXAMPLE 0 ++#define CONFIG_FILTERING_AUDIO_EXAMPLE 0 ++#define CONFIG_FILTERING_VIDEO_EXAMPLE 0 ++#define CONFIG_HTTP_MULTICLIENT_EXAMPLE 1 ++#define CONFIG_HW_DECODE_EXAMPLE 1 ++#define CONFIG_METADATA_EXAMPLE 1 ++#define CONFIG_MUXING_EXAMPLE 0 ++#define CONFIG_QSVDEC_EXAMPLE 0 ++#define CONFIG_REMUXING_EXAMPLE 1 ++#define CONFIG_RESAMPLING_AUDIO_EXAMPLE 0 ++#define CONFIG_SCALING_VIDEO_EXAMPLE 0 ++#define CONFIG_TRANSCODE_AAC_EXAMPLE 0 ++#define CONFIG_TRANSCODING_EXAMPLE 0 ++#define CONFIG_VAAPI_ENCODE_EXAMPLE 0 ++#define CONFIG_VAAPI_TRANSCODE_EXAMPLE 0 ++#define CONFIG_AVISYNTH 0 ++#define CONFIG_FREI0R 0 ++#define CONFIG_LIBCDIO 0 ++#define CONFIG_LIBDAVS2 0 ++#define CONFIG_LIBRUBBERBAND 0 ++#define CONFIG_LIBVIDSTAB 0 ++#define CONFIG_LIBX264 0 ++#define CONFIG_LIBX265 0 ++#define CONFIG_LIBXAVS 0 ++#define CONFIG_LIBXAVS2 0 ++#define CONFIG_LIBXVID 0 ++#define CONFIG_DECKLINK 0 ++#define CONFIG_LIBNDI_NEWTEK 0 ++#define CONFIG_LIBFDK_AAC 0 ++#define CONFIG_OPENSSL 0 ++#define CONFIG_LIBTLS 0 ++#define CONFIG_GMP 0 ++#define CONFIG_LIBLENSFUN 0 ++#define CONFIG_LIBOPENCORE_AMRNB 0 ++#define CONFIG_LIBOPENCORE_AMRWB 0 ++#define CONFIG_LIBVMAF 0 ++#define CONFIG_LIBVO_AMRWBENC 0 ++#define CONFIG_MBEDTLS 0 ++#define CONFIG_RKMPP 0 ++#define CONFIG_LIBSMBCLIENT 0 ++#define CONFIG_CHROMAPRINT 0 ++#define CONFIG_GCRYPT 0 ++#define CONFIG_GNUTLS 0 ++#define CONFIG_JNI 0 ++#define CONFIG_LADSPA 0 ++#define CONFIG_LIBAOM 0 ++#define CONFIG_LIBASS 0 ++#define CONFIG_LIBBLURAY 0 ++#define CONFIG_LIBBS2B 0 ++#define CONFIG_LIBCACA 0 ++#define CONFIG_LIBCELT 0 ++#define CONFIG_LIBCODEC2 0 ++#define CONFIG_LIBDAV1D 0 ++#define CONFIG_LIBDC1394 0 ++#define CONFIG_LIBDRM 0 ++#define CONFIG_LIBFLITE 0 ++#define CONFIG_LIBFONTCONFIG 0 ++#define CONFIG_LIBFREETYPE 0 ++#define CONFIG_LIBFRIBIDI 0 ++#define CONFIG_LIBGME 0 ++#define CONFIG_LIBGSM 0 ++#define CONFIG_LIBIEC61883 0 ++#define CONFIG_LIBILBC 0 ++#define CONFIG_LIBJACK 0 ++#define CONFIG_LIBKLVANC 0 ++#define CONFIG_LIBKVAZAAR 0 ++#define CONFIG_LIBMODPLUG 0 ++#define CONFIG_LIBMP3LAME 0 ++#define CONFIG_LIBMYSOFA 0 ++#define CONFIG_LIBOPENCV 0 ++#define CONFIG_LIBOPENH264 0 ++#define CONFIG_LIBOPENJPEG 0 ++#define CONFIG_LIBOPENMPT 0 ++#define CONFIG_LIBOPUS 1 ++#define CONFIG_LIBPULSE 0 ++#define CONFIG_LIBRSVG 0 ++#define CONFIG_LIBRTMP 0 ++#define CONFIG_LIBSHINE 0 ++#define CONFIG_LIBSMBCLIENT 0 ++#define CONFIG_LIBSNAPPY 0 ++#define CONFIG_LIBSOXR 0 ++#define CONFIG_LIBSPEEX 0 ++#define CONFIG_LIBSRT 0 ++#define CONFIG_LIBSSH 0 ++#define CONFIG_LIBTENSORFLOW 0 ++#define CONFIG_LIBTESSERACT 0 ++#define CONFIG_LIBTHEORA 0 ++#define CONFIG_LIBTWOLAME 0 ++#define CONFIG_LIBV4L2 0 ++#define CONFIG_LIBVORBIS 0 ++#define CONFIG_LIBVPX 0 ++#define CONFIG_LIBWAVPACK 0 ++#define CONFIG_LIBWEBP 0 ++#define CONFIG_LIBXML2 0 ++#define CONFIG_LIBZIMG 0 ++#define CONFIG_LIBZMQ 0 ++#define CONFIG_LIBZVBI 0 ++#define CONFIG_LV2 0 ++#define CONFIG_MEDIACODEC 0 ++#define CONFIG_OPENAL 0 ++#define CONFIG_OPENGL 0 ++#define CONFIG_VAPOURSYNTH 0 ++#define CONFIG_ALSA 1 ++#define CONFIG_APPKIT 0 ++#define CONFIG_AVFOUNDATION 0 ++#define CONFIG_BZLIB 0 ++#define CONFIG_COREIMAGE 0 ++#define CONFIG_ICONV 0 ++#define CONFIG_LIBXCB 0 ++#define CONFIG_LIBXCB_SHM 0 ++#define CONFIG_LIBXCB_SHAPE 0 ++#define CONFIG_LIBXCB_XFIXES 0 ++#define CONFIG_LZMA 0 ++#define CONFIG_SCHANNEL 0 ++#define CONFIG_SDL2 0 ++#define CONFIG_SECURETRANSPORT 0 ++#define CONFIG_SNDIO 0 ++#define CONFIG_XLIB 0 ++#define CONFIG_ZLIB 0 ++#define CONFIG_CUDA_SDK 0 ++#define CONFIG_LIBNPP 0 ++#define CONFIG_LIBMFX 0 ++#define CONFIG_MMAL 0 ++#define CONFIG_OMX 0 ++#define CONFIG_OPENCL 0 ++#define CONFIG_AMF 0 ++#define CONFIG_AUDIOTOOLBOX 0 ++#define CONFIG_CRYSTALHD 0 ++#define CONFIG_CUDA 0 ++#define CONFIG_CUVID 0 ++#define CONFIG_D3D11VA 0 ++#define CONFIG_DXVA2 0 ++#define CONFIG_FFNVCODEC 0 ++#define CONFIG_NVDEC 0 ++#define CONFIG_NVENC 0 ++#define CONFIG_VAAPI 0 ++#define CONFIG_VDPAU 0 ++#define CONFIG_VIDEOTOOLBOX 0 ++#define CONFIG_V4L2_M2M 0 ++#define CONFIG_XVMC 0 ++#define CONFIG_FTRAPV 0 ++#define CONFIG_GRAY 0 ++#define CONFIG_HARDCODED_TABLES 0 ++#define CONFIG_OMX_RPI 0 ++#define CONFIG_RUNTIME_CPUDETECT 1 ++#define CONFIG_SAFE_BITSTREAM_READER 1 ++#define CONFIG_SHARED 0 ++#define CONFIG_SMALL 0 ++#define CONFIG_STATIC 1 ++#define CONFIG_SWSCALE_ALPHA 1 ++#define CONFIG_GPL 0 ++#define CONFIG_NONFREE 0 ++#define CONFIG_VERSION3 0 ++#define CONFIG_AVDEVICE 0 ++#define CONFIG_AVFILTER 0 ++#define CONFIG_SWSCALE 0 ++#define CONFIG_POSTPROC 0 ++#define CONFIG_AVFORMAT 1 ++#define CONFIG_AVCODEC 1 ++#define CONFIG_SWRESAMPLE 0 ++#define CONFIG_AVRESAMPLE 0 ++#define CONFIG_AVUTIL 1 ++#define CONFIG_FFPLAY 0 ++#define CONFIG_FFPROBE 0 ++#define CONFIG_FFMPEG 0 ++#define CONFIG_DCT 1 ++#define CONFIG_DWT 0 ++#define CONFIG_ERROR_RESILIENCE 1 ++#define CONFIG_FAAN 0 ++#define CONFIG_FAST_UNALIGNED 1 ++#define CONFIG_FFT 1 ++#define CONFIG_LSP 1 ++#define CONFIG_LZO 0 ++#define CONFIG_MDCT 1 ++#define CONFIG_PIXELUTILS 0 ++#define CONFIG_NETWORK 0 ++#define CONFIG_RDFT 1 ++#define CONFIG_AUTODETECT 0 ++#define CONFIG_FONTCONFIG 0 ++#define CONFIG_LINUX_PERF 0 ++#define CONFIG_MEMORY_POISONING 0 ++#define CONFIG_NEON_CLOBBER_TEST 0 ++#define CONFIG_OSSFUZZ 0 ++#define CONFIG_PIC 1 ++#define CONFIG_THUMB 0 ++#define CONFIG_VALGRIND_BACKTRACE 0 ++#define CONFIG_XMM_CLOBBER_TEST 0 ++#define CONFIG_BSFS 1 ++#define CONFIG_DECODERS 1 ++#define CONFIG_ENCODERS 0 ++#define CONFIG_HWACCELS 0 ++#define CONFIG_PARSERS 1 ++#define CONFIG_INDEVS 0 ++#define CONFIG_OUTDEVS 0 ++#define CONFIG_FILTERS 0 ++#define CONFIG_DEMUXERS 1 ++#define CONFIG_MUXERS 0 ++#define CONFIG_PROTOCOLS 0 ++#define CONFIG_AANDCTTABLES 0 ++#define CONFIG_AC3DSP 0 ++#define CONFIG_ADTS_HEADER 1 ++#define CONFIG_AUDIO_FRAME_QUEUE 0 ++#define CONFIG_AUDIODSP 0 ++#define CONFIG_BLOCKDSP 1 ++#define CONFIG_BSWAPDSP 0 ++#define CONFIG_CABAC 1 ++#define CONFIG_CBS 0 ++#define CONFIG_CBS_AV1 0 ++#define CONFIG_CBS_H264 0 ++#define CONFIG_CBS_H265 0 ++#define CONFIG_CBS_JPEG 0 ++#define CONFIG_CBS_MPEG2 0 ++#define CONFIG_CBS_VP9 0 ++#define CONFIG_DIRAC_PARSE 1 ++#define CONFIG_DNN 0 ++#define CONFIG_DVPROFILE 0 ++#define CONFIG_EXIF 1 ++#define CONFIG_FAANDCT 0 ++#define CONFIG_FAANIDCT 0 ++#define CONFIG_FDCTDSP 1 ++#define CONFIG_FLACDSP 1 ++#define CONFIG_FMTCONVERT 0 ++#define CONFIG_FRAME_THREAD_ENCODER 0 ++#define CONFIG_G722DSP 0 ++#define CONFIG_GOLOMB 1 ++#define CONFIG_GPLV3 0 ++#define CONFIG_H263DSP 1 ++#define CONFIG_H264CHROMA 1 ++#define CONFIG_H264DSP 1 ++#define CONFIG_H264PARSE 1 ++#define CONFIG_H264PRED 1 ++#define CONFIG_H264QPEL 1 ++#define CONFIG_HEVCPARSE 0 ++#define CONFIG_HPELDSP 1 ++#define CONFIG_HUFFMAN 0 ++#define CONFIG_HUFFYUVDSP 0 ++#define CONFIG_HUFFYUVENCDSP 0 ++#define CONFIG_IDCTDSP 1 ++#define CONFIG_IIRFILTER 0 ++#define CONFIG_MDCT15 1 ++#define CONFIG_INTRAX8 0 ++#define CONFIG_ISO_MEDIA 1 ++#define CONFIG_IVIDSP 0 ++#define CONFIG_JPEGTABLES 0 ++#define CONFIG_LGPLV3 0 ++#define CONFIG_LIBX262 0 ++#define CONFIG_LLAUDDSP 0 ++#define CONFIG_LLVIDDSP 0 ++#define CONFIG_LLVIDENCDSP 0 ++#define CONFIG_LPC 0 ++#define CONFIG_LZF 0 ++#define CONFIG_ME_CMP 1 ++#define CONFIG_MPEG_ER 1 ++#define CONFIG_MPEGAUDIO 1 ++#define CONFIG_MPEGAUDIODSP 1 ++#define CONFIG_MPEGAUDIOHEADER 1 ++#define CONFIG_MPEGVIDEO 1 ++#define CONFIG_MPEGVIDEOENC 0 ++#define CONFIG_MSS34DSP 0 ++#define CONFIG_PIXBLOCKDSP 1 ++#define CONFIG_QPELDSP 1 ++#define CONFIG_QSV 0 ++#define CONFIG_QSVDEC 0 ++#define CONFIG_QSVENC 0 ++#define CONFIG_QSVVPP 0 ++#define CONFIG_RANGECODER 0 ++#define CONFIG_RIFFDEC 1 ++#define CONFIG_RIFFENC 0 ++#define CONFIG_RTPDEC 0 ++#define CONFIG_RTPENC_CHAIN 0 ++#define CONFIG_RV34DSP 0 ++#define CONFIG_SCENE_SAD 0 ++#define CONFIG_SINEWIN 1 ++#define CONFIG_SNAPPY 0 ++#define CONFIG_SRTP 0 ++#define CONFIG_STARTCODE 1 ++#define CONFIG_TEXTUREDSP 0 ++#define CONFIG_TEXTUREDSPENC 0 ++#define CONFIG_TPELDSP 0 ++#define CONFIG_VAAPI_1 0 ++#define CONFIG_VAAPI_ENCODE 0 ++#define CONFIG_VC1DSP 0 ++#define CONFIG_VIDEODSP 1 ++#define CONFIG_VP3DSP 1 ++#define CONFIG_VP56DSP 0 ++#define CONFIG_VP8DSP 1 ++#define CONFIG_WMA_FREQS 0 ++#define CONFIG_WMV2DSP 0 ++#define CONFIG_AAC_ADTSTOASC_BSF 0 ++#define CONFIG_AV1_METADATA_BSF 0 ++#define CONFIG_CHOMP_BSF 0 ++#define CONFIG_DUMP_EXTRADATA_BSF 0 ++#define CONFIG_DCA_CORE_BSF 0 ++#define CONFIG_EAC3_CORE_BSF 0 ++#define CONFIG_EXTRACT_EXTRADATA_BSF 0 ++#define CONFIG_FILTER_UNITS_BSF 0 ++#define CONFIG_H264_METADATA_BSF 0 ++#define CONFIG_H264_MP4TOANNEXB_BSF 0 ++#define CONFIG_H264_REDUNDANT_PPS_BSF 0 ++#define CONFIG_HAPQA_EXTRACT_BSF 0 ++#define CONFIG_HEVC_METADATA_BSF 0 ++#define CONFIG_HEVC_MP4TOANNEXB_BSF 0 ++#define CONFIG_IMX_DUMP_HEADER_BSF 0 ++#define CONFIG_MJPEG2JPEG_BSF 0 ++#define CONFIG_MJPEGA_DUMP_HEADER_BSF 0 ++#define CONFIG_MP3_HEADER_DECOMPRESS_BSF 0 ++#define CONFIG_MPEG2_METADATA_BSF 0 ++#define CONFIG_MPEG4_UNPACK_BFRAMES_BSF 0 ++#define CONFIG_MOV2TEXTSUB_BSF 0 ++#define CONFIG_NOISE_BSF 0 ++#define CONFIG_NULL_BSF 1 ++#define CONFIG_PRORES_METADATA_BSF 0 ++#define CONFIG_REMOVE_EXTRADATA_BSF 0 ++#define CONFIG_TEXT2MOVSUB_BSF 0 ++#define CONFIG_TRACE_HEADERS_BSF 0 ++#define CONFIG_TRUEHD_CORE_BSF 0 ++#define CONFIG_VP9_METADATA_BSF 0 ++#define CONFIG_VP9_RAW_REORDER_BSF 0 ++#define CONFIG_VP9_SUPERFRAME_BSF 0 ++#define CONFIG_VP9_SUPERFRAME_SPLIT_BSF 0 ++#define CONFIG_AASC_DECODER 0 ++#define CONFIG_AIC_DECODER 0 ++#define CONFIG_ALIAS_PIX_DECODER 0 ++#define CONFIG_AMV_DECODER 0 ++#define CONFIG_ANM_DECODER 0 ++#define CONFIG_ANSI_DECODER 0 ++#define CONFIG_APNG_DECODER 0 ++#define CONFIG_ASV1_DECODER 0 ++#define CONFIG_ASV2_DECODER 0 ++#define CONFIG_AURA_DECODER 0 ++#define CONFIG_AURA2_DECODER 0 ++#define CONFIG_AVRP_DECODER 0 ++#define CONFIG_AVRN_DECODER 0 ++#define CONFIG_AVS_DECODER 0 ++#define CONFIG_AVUI_DECODER 0 ++#define CONFIG_AYUV_DECODER 0 ++#define CONFIG_BETHSOFTVID_DECODER 0 ++#define CONFIG_BFI_DECODER 0 ++#define CONFIG_BINK_DECODER 0 ++#define CONFIG_BITPACKED_DECODER 0 ++#define CONFIG_BMP_DECODER 0 ++#define CONFIG_BMV_VIDEO_DECODER 0 ++#define CONFIG_BRENDER_PIX_DECODER 0 ++#define CONFIG_C93_DECODER 0 ++#define CONFIG_CAVS_DECODER 0 ++#define CONFIG_CDGRAPHICS_DECODER 0 ++#define CONFIG_CDXL_DECODER 0 ++#define CONFIG_CFHD_DECODER 0 ++#define CONFIG_CINEPAK_DECODER 0 ++#define CONFIG_CLEARVIDEO_DECODER 0 ++#define CONFIG_CLJR_DECODER 0 ++#define CONFIG_CLLC_DECODER 0 ++#define CONFIG_COMFORTNOISE_DECODER 0 ++#define CONFIG_CPIA_DECODER 0 ++#define CONFIG_CSCD_DECODER 0 ++#define CONFIG_CYUV_DECODER 0 ++#define CONFIG_DDS_DECODER 0 ++#define CONFIG_DFA_DECODER 0 ++#define CONFIG_DIRAC_DECODER 0 ++#define CONFIG_DNXHD_DECODER 0 ++#define CONFIG_DPX_DECODER 0 ++#define CONFIG_DSICINVIDEO_DECODER 0 ++#define CONFIG_DVAUDIO_DECODER 0 ++#define CONFIG_DVVIDEO_DECODER 0 ++#define CONFIG_DXA_DECODER 0 ++#define CONFIG_DXTORY_DECODER 0 ++#define CONFIG_DXV_DECODER 0 ++#define CONFIG_EACMV_DECODER 0 ++#define CONFIG_EAMAD_DECODER 0 ++#define CONFIG_EATGQ_DECODER 0 ++#define CONFIG_EATGV_DECODER 0 ++#define CONFIG_EATQI_DECODER 0 ++#define CONFIG_EIGHTBPS_DECODER 0 ++#define CONFIG_EIGHTSVX_EXP_DECODER 0 ++#define CONFIG_EIGHTSVX_FIB_DECODER 0 ++#define CONFIG_ESCAPE124_DECODER 0 ++#define CONFIG_ESCAPE130_DECODER 0 ++#define CONFIG_EXR_DECODER 0 ++#define CONFIG_FFV1_DECODER 0 ++#define CONFIG_FFVHUFF_DECODER 0 ++#define CONFIG_FIC_DECODER 0 ++#define CONFIG_FITS_DECODER 0 ++#define CONFIG_FLASHSV_DECODER 0 ++#define CONFIG_FLASHSV2_DECODER 0 ++#define CONFIG_FLIC_DECODER 0 ++#define CONFIG_FLV_DECODER 0 ++#define CONFIG_FMVC_DECODER 0 ++#define CONFIG_FOURXM_DECODER 0 ++#define CONFIG_FRAPS_DECODER 0 ++#define CONFIG_FRWU_DECODER 0 ++#define CONFIG_G2M_DECODER 0 ++#define CONFIG_GDV_DECODER 0 ++#define CONFIG_GIF_DECODER 0 ++#define CONFIG_H261_DECODER 0 ++#define CONFIG_H263_DECODER 1 ++#define CONFIG_H263I_DECODER 0 ++#define CONFIG_H263P_DECODER 0 ++#define CONFIG_H263_V4L2M2M_DECODER 0 ++#define CONFIG_H264_DECODER 1 ++#define CONFIG_H264_CRYSTALHD_DECODER 0 ++#define CONFIG_H264_V4L2M2M_DECODER 0 ++#define CONFIG_H264_MEDIACODEC_DECODER 0 ++#define CONFIG_H264_MMAL_DECODER 0 ++#define CONFIG_H264_QSV_DECODER 0 ++#define CONFIG_H264_RKMPP_DECODER 0 ++#define CONFIG_HAP_DECODER 0 ++#define CONFIG_HEVC_DECODER 0 ++#define CONFIG_HEVC_QSV_DECODER 0 ++#define CONFIG_HEVC_RKMPP_DECODER 0 ++#define CONFIG_HEVC_V4L2M2M_DECODER 0 ++#define CONFIG_HNM4_VIDEO_DECODER 0 ++#define CONFIG_HQ_HQA_DECODER 0 ++#define CONFIG_HQX_DECODER 0 ++#define CONFIG_HUFFYUV_DECODER 0 ++#define CONFIG_IDCIN_DECODER 0 ++#define CONFIG_IFF_ILBM_DECODER 0 ++#define CONFIG_IMM4_DECODER 0 ++#define CONFIG_INDEO2_DECODER 0 ++#define CONFIG_INDEO3_DECODER 0 ++#define CONFIG_INDEO4_DECODER 0 ++#define CONFIG_INDEO5_DECODER 0 ++#define CONFIG_INTERPLAY_VIDEO_DECODER 0 ++#define CONFIG_JPEG2000_DECODER 0 ++#define CONFIG_JPEGLS_DECODER 0 ++#define CONFIG_JV_DECODER 0 ++#define CONFIG_KGV1_DECODER 0 ++#define CONFIG_KMVC_DECODER 0 ++#define CONFIG_LAGARITH_DECODER 0 ++#define CONFIG_LOCO_DECODER 0 ++#define CONFIG_M101_DECODER 0 ++#define CONFIG_MAGICYUV_DECODER 0 ++#define CONFIG_MDEC_DECODER 0 ++#define CONFIG_MIMIC_DECODER 0 ++#define CONFIG_MJPEG_DECODER 0 ++#define CONFIG_MJPEGB_DECODER 0 ++#define CONFIG_MMVIDEO_DECODER 0 ++#define CONFIG_MOTIONPIXELS_DECODER 0 ++#define CONFIG_MPEG1VIDEO_DECODER 0 ++#define CONFIG_MPEG2VIDEO_DECODER 0 ++#define CONFIG_MPEG4_DECODER 1 ++#define CONFIG_MPEG4_CRYSTALHD_DECODER 0 ++#define CONFIG_MPEG4_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG4_MMAL_DECODER 0 ++#define CONFIG_MPEGVIDEO_DECODER 0 ++#define CONFIG_MPEG1_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG2_MMAL_DECODER 0 ++#define CONFIG_MPEG2_CRYSTALHD_DECODER 0 ++#define CONFIG_MPEG2_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG2_QSV_DECODER 0 ++#define CONFIG_MPEG2_MEDIACODEC_DECODER 0 ++#define CONFIG_MSA1_DECODER 0 ++#define CONFIG_MSCC_DECODER 0 ++#define CONFIG_MSMPEG4V1_DECODER 0 ++#define CONFIG_MSMPEG4V2_DECODER 0 ++#define CONFIG_MSMPEG4V3_DECODER 0 ++#define CONFIG_MSMPEG4_CRYSTALHD_DECODER 0 ++#define CONFIG_MSRLE_DECODER 0 ++#define CONFIG_MSS1_DECODER 0 ++#define CONFIG_MSS2_DECODER 0 ++#define CONFIG_MSVIDEO1_DECODER 0 ++#define CONFIG_MSZH_DECODER 0 ++#define CONFIG_MTS2_DECODER 0 ++#define CONFIG_MVC1_DECODER 0 ++#define CONFIG_MVC2_DECODER 0 ++#define CONFIG_MWSC_DECODER 0 ++#define CONFIG_MXPEG_DECODER 0 ++#define CONFIG_NUV_DECODER 0 ++#define CONFIG_PAF_VIDEO_DECODER 0 ++#define CONFIG_PAM_DECODER 0 ++#define CONFIG_PBM_DECODER 0 ++#define CONFIG_PCX_DECODER 0 ++#define CONFIG_PGM_DECODER 0 ++#define CONFIG_PGMYUV_DECODER 0 ++#define CONFIG_PICTOR_DECODER 0 ++#define CONFIG_PIXLET_DECODER 0 ++#define CONFIG_PNG_DECODER 0 ++#define CONFIG_PPM_DECODER 0 ++#define CONFIG_PRORES_DECODER 0 ++#define CONFIG_PROSUMER_DECODER 0 ++#define CONFIG_PSD_DECODER 0 ++#define CONFIG_PTX_DECODER 0 ++#define CONFIG_QDRAW_DECODER 0 ++#define CONFIG_QPEG_DECODER 0 ++#define CONFIG_QTRLE_DECODER 0 ++#define CONFIG_R10K_DECODER 0 ++#define CONFIG_R210_DECODER 0 ++#define CONFIG_RASC_DECODER 0 ++#define CONFIG_RAWVIDEO_DECODER 0 ++#define CONFIG_RL2_DECODER 0 ++#define CONFIG_ROQ_DECODER 0 ++#define CONFIG_RPZA_DECODER 0 ++#define CONFIG_RSCC_DECODER 0 ++#define CONFIG_RV10_DECODER 0 ++#define CONFIG_RV20_DECODER 0 ++#define CONFIG_RV30_DECODER 0 ++#define CONFIG_RV40_DECODER 0 ++#define CONFIG_S302M_DECODER 0 ++#define CONFIG_SANM_DECODER 0 ++#define CONFIG_SCPR_DECODER 0 ++#define CONFIG_SCREENPRESSO_DECODER 0 ++#define CONFIG_SDX2_DPCM_DECODER 0 ++#define CONFIG_SGI_DECODER 0 ++#define CONFIG_SGIRLE_DECODER 0 ++#define CONFIG_SHEERVIDEO_DECODER 0 ++#define CONFIG_SMACKER_DECODER 0 ++#define CONFIG_SMC_DECODER 0 ++#define CONFIG_SMVJPEG_DECODER 0 ++#define CONFIG_SNOW_DECODER 0 ++#define CONFIG_SP5X_DECODER 0 ++#define CONFIG_SPEEDHQ_DECODER 0 ++#define CONFIG_SRGC_DECODER 0 ++#define CONFIG_SUNRAST_DECODER 0 ++#define CONFIG_SVQ1_DECODER 0 ++#define CONFIG_SVQ3_DECODER 0 ++#define CONFIG_TARGA_DECODER 0 ++#define CONFIG_TARGA_Y216_DECODER 0 ++#define CONFIG_TDSC_DECODER 0 ++#define CONFIG_THEORA_DECODER 1 ++#define CONFIG_THP_DECODER 0 ++#define CONFIG_TIERTEXSEQVIDEO_DECODER 0 ++#define CONFIG_TIFF_DECODER 0 ++#define CONFIG_TMV_DECODER 0 ++#define CONFIG_TRUEMOTION1_DECODER 0 ++#define CONFIG_TRUEMOTION2_DECODER 0 ++#define CONFIG_TRUEMOTION2RT_DECODER 0 ++#define CONFIG_TSCC_DECODER 0 ++#define CONFIG_TSCC2_DECODER 0 ++#define CONFIG_TXD_DECODER 0 ++#define CONFIG_ULTI_DECODER 0 ++#define CONFIG_UTVIDEO_DECODER 0 ++#define CONFIG_V210_DECODER 0 ++#define CONFIG_V210X_DECODER 0 ++#define CONFIG_V308_DECODER 0 ++#define CONFIG_V408_DECODER 0 ++#define CONFIG_V410_DECODER 0 ++#define CONFIG_VB_DECODER 0 ++#define CONFIG_VBLE_DECODER 0 ++#define CONFIG_VC1_DECODER 0 ++#define CONFIG_VC1_CRYSTALHD_DECODER 0 ++#define CONFIG_VC1IMAGE_DECODER 0 ++#define CONFIG_VC1_MMAL_DECODER 0 ++#define CONFIG_VC1_QSV_DECODER 0 ++#define CONFIG_VC1_V4L2M2M_DECODER 0 ++#define CONFIG_VCR1_DECODER 0 ++#define CONFIG_VMDVIDEO_DECODER 0 ++#define CONFIG_VMNC_DECODER 0 ++#define CONFIG_VP3_DECODER 1 ++#define CONFIG_VP5_DECODER 0 ++#define CONFIG_VP6_DECODER 0 ++#define CONFIG_VP6A_DECODER 0 ++#define CONFIG_VP6F_DECODER 0 ++#define CONFIG_VP7_DECODER 0 ++#define CONFIG_VP8_DECODER 1 ++#define CONFIG_VP8_RKMPP_DECODER 0 ++#define CONFIG_VP8_V4L2M2M_DECODER 0 ++#define CONFIG_VP9_DECODER 0 ++#define CONFIG_VP9_RKMPP_DECODER 0 ++#define CONFIG_VP9_V4L2M2M_DECODER 0 ++#define CONFIG_VQA_DECODER 0 ++#define CONFIG_WEBP_DECODER 0 ++#define CONFIG_WCMV_DECODER 0 ++#define CONFIG_WRAPPED_AVFRAME_DECODER 0 ++#define CONFIG_WMV1_DECODER 0 ++#define CONFIG_WMV2_DECODER 0 ++#define CONFIG_WMV3_DECODER 0 ++#define CONFIG_WMV3_CRYSTALHD_DECODER 0 ++#define CONFIG_WMV3IMAGE_DECODER 0 ++#define CONFIG_WNV1_DECODER 0 ++#define CONFIG_XAN_WC3_DECODER 0 ++#define CONFIG_XAN_WC4_DECODER 0 ++#define CONFIG_XBM_DECODER 0 ++#define CONFIG_XFACE_DECODER 0 ++#define CONFIG_XL_DECODER 0 ++#define CONFIG_XPM_DECODER 0 ++#define CONFIG_XWD_DECODER 0 ++#define CONFIG_Y41P_DECODER 0 ++#define CONFIG_YLC_DECODER 0 ++#define CONFIG_YOP_DECODER 0 ++#define CONFIG_YUV4_DECODER 0 ++#define CONFIG_ZERO12V_DECODER 0 ++#define CONFIG_ZEROCODEC_DECODER 0 ++#define CONFIG_ZLIB_DECODER 0 ++#define CONFIG_ZMBV_DECODER 0 ++#define CONFIG_AAC_DECODER 1 ++#define CONFIG_AAC_FIXED_DECODER 0 ++#define CONFIG_AAC_LATM_DECODER 0 ++#define CONFIG_AC3_DECODER 0 ++#define CONFIG_AC3_FIXED_DECODER 0 ++#define CONFIG_ALAC_DECODER 0 ++#define CONFIG_ALS_DECODER 0 ++#define CONFIG_AMRNB_DECODER 1 ++#define CONFIG_AMRWB_DECODER 1 ++#define CONFIG_APE_DECODER 0 ++#define CONFIG_APTX_DECODER 0 ++#define CONFIG_APTX_HD_DECODER 0 ++#define CONFIG_ATRAC1_DECODER 0 ++#define CONFIG_ATRAC3_DECODER 0 ++#define CONFIG_ATRAC3AL_DECODER 0 ++#define CONFIG_ATRAC3P_DECODER 0 ++#define CONFIG_ATRAC3PAL_DECODER 0 ++#define CONFIG_ATRAC9_DECODER 0 ++#define CONFIG_BINKAUDIO_DCT_DECODER 0 ++#define CONFIG_BINKAUDIO_RDFT_DECODER 0 ++#define CONFIG_BMV_AUDIO_DECODER 0 ++#define CONFIG_COOK_DECODER 0 ++#define CONFIG_DCA_DECODER 0 ++#define CONFIG_DOLBY_E_DECODER 0 ++#define CONFIG_DSD_LSBF_DECODER 0 ++#define CONFIG_DSD_MSBF_DECODER 0 ++#define CONFIG_DSD_LSBF_PLANAR_DECODER 0 ++#define CONFIG_DSD_MSBF_PLANAR_DECODER 0 ++#define CONFIG_DSICINAUDIO_DECODER 0 ++#define CONFIG_DSS_SP_DECODER 0 ++#define CONFIG_DST_DECODER 0 ++#define CONFIG_EAC3_DECODER 0 ++#define CONFIG_EVRC_DECODER 0 ++#define CONFIG_FFWAVESYNTH_DECODER 0 ++#define CONFIG_FLAC_DECODER 1 ++#define CONFIG_G723_1_DECODER 0 ++#define CONFIG_G729_DECODER 0 ++#define CONFIG_GSM_DECODER 0 ++#define CONFIG_GSM_MS_DECODER 1 ++#define CONFIG_IAC_DECODER 0 ++#define CONFIG_ILBC_DECODER 0 ++#define CONFIG_IMC_DECODER 0 ++#define CONFIG_INTERPLAY_ACM_DECODER 0 ++#define CONFIG_MACE3_DECODER 0 ++#define CONFIG_MACE6_DECODER 0 ++#define CONFIG_METASOUND_DECODER 0 ++#define CONFIG_MLP_DECODER 0 ++#define CONFIG_MP1_DECODER 0 ++#define CONFIG_MP1FLOAT_DECODER 0 ++#define CONFIG_MP2_DECODER 0 ++#define CONFIG_MP2FLOAT_DECODER 0 ++#define CONFIG_MP3FLOAT_DECODER 0 ++#define CONFIG_MP3_DECODER 1 ++#define CONFIG_MP3ADUFLOAT_DECODER 0 ++#define CONFIG_MP3ADU_DECODER 0 ++#define CONFIG_MP3ON4FLOAT_DECODER 0 ++#define CONFIG_MP3ON4_DECODER 0 ++#define CONFIG_MPC7_DECODER 0 ++#define CONFIG_MPC8_DECODER 0 ++#define CONFIG_NELLYMOSER_DECODER 0 ++#define CONFIG_ON2AVC_DECODER 0 ++#define CONFIG_OPUS_DECODER 0 ++#define CONFIG_PAF_AUDIO_DECODER 0 ++#define CONFIG_QCELP_DECODER 0 ++#define CONFIG_QDM2_DECODER 0 ++#define CONFIG_QDMC_DECODER 0 ++#define CONFIG_RA_144_DECODER 0 ++#define CONFIG_RA_288_DECODER 0 ++#define CONFIG_RALF_DECODER 0 ++#define CONFIG_SBC_DECODER 0 ++#define CONFIG_SHORTEN_DECODER 0 ++#define CONFIG_SIPR_DECODER 0 ++#define CONFIG_SMACKAUD_DECODER 0 ++#define CONFIG_SONIC_DECODER 0 ++#define CONFIG_TAK_DECODER 0 ++#define CONFIG_TRUEHD_DECODER 0 ++#define CONFIG_TRUESPEECH_DECODER 0 ++#define CONFIG_TTA_DECODER 0 ++#define CONFIG_TWINVQ_DECODER 0 ++#define CONFIG_VMDAUDIO_DECODER 0 ++#define CONFIG_VORBIS_DECODER 1 ++#define CONFIG_WAVPACK_DECODER 0 ++#define CONFIG_WMALOSSLESS_DECODER 0 ++#define CONFIG_WMAPRO_DECODER 0 ++#define CONFIG_WMAV1_DECODER 0 ++#define CONFIG_WMAV2_DECODER 0 ++#define CONFIG_WMAVOICE_DECODER 0 ++#define CONFIG_WS_SND1_DECODER 0 ++#define CONFIG_XMA1_DECODER 0 ++#define CONFIG_XMA2_DECODER 0 ++#define CONFIG_PCM_ALAW_DECODER 1 ++#define CONFIG_PCM_BLURAY_DECODER 0 ++#define CONFIG_PCM_DVD_DECODER 0 ++#define CONFIG_PCM_F16LE_DECODER 0 ++#define CONFIG_PCM_F24LE_DECODER 0 ++#define CONFIG_PCM_F32BE_DECODER 0 ++#define CONFIG_PCM_F32LE_DECODER 1 ++#define CONFIG_PCM_F64BE_DECODER 0 ++#define CONFIG_PCM_F64LE_DECODER 0 ++#define CONFIG_PCM_LXF_DECODER 0 ++#define CONFIG_PCM_MULAW_DECODER 1 ++#define CONFIG_PCM_S8_DECODER 0 ++#define CONFIG_PCM_S8_PLANAR_DECODER 0 ++#define CONFIG_PCM_S16BE_DECODER 1 ++#define CONFIG_PCM_S16BE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S16LE_DECODER 1 ++#define CONFIG_PCM_S16LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S24BE_DECODER 1 ++#define CONFIG_PCM_S24DAUD_DECODER 0 ++#define CONFIG_PCM_S24LE_DECODER 1 ++#define CONFIG_PCM_S24LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S32BE_DECODER 0 ++#define CONFIG_PCM_S32LE_DECODER 1 ++#define CONFIG_PCM_S32LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S64BE_DECODER 0 ++#define CONFIG_PCM_S64LE_DECODER 0 ++#define CONFIG_PCM_U8_DECODER 1 ++#define CONFIG_PCM_U16BE_DECODER 0 ++#define CONFIG_PCM_U16LE_DECODER 0 ++#define CONFIG_PCM_U24BE_DECODER 0 ++#define CONFIG_PCM_U24LE_DECODER 0 ++#define CONFIG_PCM_U32BE_DECODER 0 ++#define CONFIG_PCM_U32LE_DECODER 0 ++#define CONFIG_PCM_VIDC_DECODER 0 ++#define CONFIG_PCM_ZORK_DECODER 0 ++#define CONFIG_GREMLIN_DPCM_DECODER 0 ++#define CONFIG_INTERPLAY_DPCM_DECODER 0 ++#define CONFIG_ROQ_DPCM_DECODER 0 ++#define CONFIG_SOL_DPCM_DECODER 0 ++#define CONFIG_XAN_DPCM_DECODER 0 ++#define CONFIG_ADPCM_4XM_DECODER 0 ++#define CONFIG_ADPCM_ADX_DECODER 0 ++#define CONFIG_ADPCM_AFC_DECODER 0 ++#define CONFIG_ADPCM_AICA_DECODER 0 ++#define CONFIG_ADPCM_CT_DECODER 0 ++#define CONFIG_ADPCM_DTK_DECODER 0 ++#define CONFIG_ADPCM_EA_DECODER 0 ++#define CONFIG_ADPCM_EA_MAXIS_XA_DECODER 0 ++#define CONFIG_ADPCM_EA_R1_DECODER 0 ++#define CONFIG_ADPCM_EA_R2_DECODER 0 ++#define CONFIG_ADPCM_EA_R3_DECODER 0 ++#define CONFIG_ADPCM_EA_XAS_DECODER 0 ++#define CONFIG_ADPCM_G722_DECODER 0 ++#define CONFIG_ADPCM_G726_DECODER 0 ++#define CONFIG_ADPCM_G726LE_DECODER 0 ++#define CONFIG_ADPCM_IMA_AMV_DECODER 0 ++#define CONFIG_ADPCM_IMA_APC_DECODER 0 ++#define CONFIG_ADPCM_IMA_DAT4_DECODER 0 ++#define CONFIG_ADPCM_IMA_DK3_DECODER 0 ++#define CONFIG_ADPCM_IMA_DK4_DECODER 0 ++#define CONFIG_ADPCM_IMA_EA_EACS_DECODER 0 ++#define CONFIG_ADPCM_IMA_EA_SEAD_DECODER 0 ++#define CONFIG_ADPCM_IMA_ISS_DECODER 0 ++#define CONFIG_ADPCM_IMA_OKI_DECODER 0 ++#define CONFIG_ADPCM_IMA_QT_DECODER 0 ++#define CONFIG_ADPCM_IMA_RAD_DECODER 0 ++#define CONFIG_ADPCM_IMA_SMJPEG_DECODER 0 ++#define CONFIG_ADPCM_IMA_WAV_DECODER 0 ++#define CONFIG_ADPCM_IMA_WS_DECODER 0 ++#define CONFIG_ADPCM_MS_DECODER 0 ++#define CONFIG_ADPCM_MTAF_DECODER 0 ++#define CONFIG_ADPCM_PSX_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_2_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_3_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_4_DECODER 0 ++#define CONFIG_ADPCM_SWF_DECODER 0 ++#define CONFIG_ADPCM_THP_DECODER 0 ++#define CONFIG_ADPCM_THP_LE_DECODER 0 ++#define CONFIG_ADPCM_VIMA_DECODER 0 ++#define CONFIG_ADPCM_XA_DECODER 0 ++#define CONFIG_ADPCM_YAMAHA_DECODER 0 ++#define CONFIG_SSA_DECODER 0 ++#define CONFIG_ASS_DECODER 0 ++#define CONFIG_CCAPTION_DECODER 0 ++#define CONFIG_DVBSUB_DECODER 0 ++#define CONFIG_DVDSUB_DECODER 0 ++#define CONFIG_JACOSUB_DECODER 0 ++#define CONFIG_MICRODVD_DECODER 0 ++#define CONFIG_MOVTEXT_DECODER 0 ++#define CONFIG_MPL2_DECODER 0 ++#define CONFIG_PGSSUB_DECODER 0 ++#define CONFIG_PJS_DECODER 0 ++#define CONFIG_REALTEXT_DECODER 0 ++#define CONFIG_SAMI_DECODER 0 ++#define CONFIG_SRT_DECODER 0 ++#define CONFIG_STL_DECODER 0 ++#define CONFIG_SUBRIP_DECODER 0 ++#define CONFIG_SUBVIEWER_DECODER 0 ++#define CONFIG_SUBVIEWER1_DECODER 0 ++#define CONFIG_TEXT_DECODER 0 ++#define CONFIG_VPLAYER_DECODER 0 ++#define CONFIG_WEBVTT_DECODER 0 ++#define CONFIG_XSUB_DECODER 0 ++#define CONFIG_AAC_AT_DECODER 0 ++#define CONFIG_AC3_AT_DECODER 0 ++#define CONFIG_ADPCM_IMA_QT_AT_DECODER 0 ++#define CONFIG_ALAC_AT_DECODER 0 ++#define CONFIG_AMR_NB_AT_DECODER 0 ++#define CONFIG_EAC3_AT_DECODER 0 ++#define CONFIG_GSM_MS_AT_DECODER 0 ++#define CONFIG_ILBC_AT_DECODER 0 ++#define CONFIG_MP1_AT_DECODER 0 ++#define CONFIG_MP2_AT_DECODER 0 ++#define CONFIG_MP3_AT_DECODER 0 ++#define CONFIG_PCM_ALAW_AT_DECODER 0 ++#define CONFIG_PCM_MULAW_AT_DECODER 0 ++#define CONFIG_QDMC_AT_DECODER 0 ++#define CONFIG_QDM2_AT_DECODER 0 ++#define CONFIG_LIBAOM_AV1_DECODER 0 ++#define CONFIG_LIBCELT_DECODER 0 ++#define CONFIG_LIBCODEC2_DECODER 0 ++#define CONFIG_LIBDAV1D_DECODER 0 ++#define CONFIG_LIBDAVS2_DECODER 0 ++#define CONFIG_LIBFDK_AAC_DECODER 0 ++#define CONFIG_LIBGSM_DECODER 0 ++#define CONFIG_LIBGSM_MS_DECODER 0 ++#define CONFIG_LIBILBC_DECODER 0 ++#define CONFIG_LIBOPENCORE_AMRNB_DECODER 0 ++#define CONFIG_LIBOPENCORE_AMRWB_DECODER 0 ++#define CONFIG_LIBOPENJPEG_DECODER 0 ++#define CONFIG_LIBOPUS_DECODER 1 ++#define CONFIG_LIBRSVG_DECODER 0 ++#define CONFIG_LIBSPEEX_DECODER 0 ++#define CONFIG_LIBVORBIS_DECODER 0 ++#define CONFIG_LIBVPX_VP8_DECODER 0 ++#define CONFIG_LIBVPX_VP9_DECODER 0 ++#define CONFIG_LIBZVBI_TELETEXT_DECODER 0 ++#define CONFIG_BINTEXT_DECODER 0 ++#define CONFIG_XBIN_DECODER 0 ++#define CONFIG_IDF_DECODER 0 ++#define CONFIG_LIBOPENH264_DECODER 0 ++#define CONFIG_H264_CUVID_DECODER 0 ++#define CONFIG_HEVC_CUVID_DECODER 0 ++#define CONFIG_HEVC_MEDIACODEC_DECODER 0 ++#define CONFIG_MJPEG_CUVID_DECODER 0 ++#define CONFIG_MPEG1_CUVID_DECODER 0 ++#define CONFIG_MPEG2_CUVID_DECODER 0 ++#define CONFIG_MPEG4_CUVID_DECODER 0 ++#define CONFIG_MPEG4_MEDIACODEC_DECODER 0 ++#define CONFIG_VC1_CUVID_DECODER 0 ++#define CONFIG_VP8_CUVID_DECODER 0 ++#define CONFIG_VP8_MEDIACODEC_DECODER 0 ++#define CONFIG_VP8_QSV_DECODER 0 ++#define CONFIG_VP9_CUVID_DECODER 0 ++#define CONFIG_VP9_MEDIACODEC_DECODER 0 ++#define CONFIG_A64MULTI_ENCODER 0 ++#define CONFIG_A64MULTI5_ENCODER 0 ++#define CONFIG_ALIAS_PIX_ENCODER 0 ++#define CONFIG_AMV_ENCODER 0 ++#define CONFIG_APNG_ENCODER 0 ++#define CONFIG_ASV1_ENCODER 0 ++#define CONFIG_ASV2_ENCODER 0 ++#define CONFIG_AVRP_ENCODER 0 ++#define CONFIG_AVUI_ENCODER 0 ++#define CONFIG_AYUV_ENCODER 0 ++#define CONFIG_BMP_ENCODER 0 ++#define CONFIG_CINEPAK_ENCODER 0 ++#define CONFIG_CLJR_ENCODER 0 ++#define CONFIG_COMFORTNOISE_ENCODER 0 ++#define CONFIG_DNXHD_ENCODER 0 ++#define CONFIG_DPX_ENCODER 0 ++#define CONFIG_DVVIDEO_ENCODER 0 ++#define CONFIG_FFV1_ENCODER 0 ++#define CONFIG_FFVHUFF_ENCODER 0 ++#define CONFIG_FITS_ENCODER 0 ++#define CONFIG_FLASHSV_ENCODER 0 ++#define CONFIG_FLASHSV2_ENCODER 0 ++#define CONFIG_FLV_ENCODER 0 ++#define CONFIG_GIF_ENCODER 0 ++#define CONFIG_H261_ENCODER 0 ++#define CONFIG_H263_ENCODER 0 ++#define CONFIG_H263P_ENCODER 0 ++#define CONFIG_HAP_ENCODER 0 ++#define CONFIG_HUFFYUV_ENCODER 0 ++#define CONFIG_JPEG2000_ENCODER 0 ++#define CONFIG_JPEGLS_ENCODER 0 ++#define CONFIG_LJPEG_ENCODER 0 ++#define CONFIG_MAGICYUV_ENCODER 0 ++#define CONFIG_MJPEG_ENCODER 0 ++#define CONFIG_MPEG1VIDEO_ENCODER 0 ++#define CONFIG_MPEG2VIDEO_ENCODER 0 ++#define CONFIG_MPEG4_ENCODER 0 ++#define CONFIG_MSMPEG4V2_ENCODER 0 ++#define CONFIG_MSMPEG4V3_ENCODER 0 ++#define CONFIG_MSVIDEO1_ENCODER 0 ++#define CONFIG_PAM_ENCODER 0 ++#define CONFIG_PBM_ENCODER 0 ++#define CONFIG_PCX_ENCODER 0 ++#define CONFIG_PGM_ENCODER 0 ++#define CONFIG_PGMYUV_ENCODER 0 ++#define CONFIG_PNG_ENCODER 0 ++#define CONFIG_PPM_ENCODER 0 ++#define CONFIG_PRORES_ENCODER 0 ++#define CONFIG_PRORES_AW_ENCODER 0 ++#define CONFIG_PRORES_KS_ENCODER 0 ++#define CONFIG_QTRLE_ENCODER 0 ++#define CONFIG_R10K_ENCODER 0 ++#define CONFIG_R210_ENCODER 0 ++#define CONFIG_RAWVIDEO_ENCODER 0 ++#define CONFIG_ROQ_ENCODER 0 ++#define CONFIG_RV10_ENCODER 0 ++#define CONFIG_RV20_ENCODER 0 ++#define CONFIG_S302M_ENCODER 0 ++#define CONFIG_SGI_ENCODER 0 ++#define CONFIG_SNOW_ENCODER 0 ++#define CONFIG_SUNRAST_ENCODER 0 ++#define CONFIG_SVQ1_ENCODER 0 ++#define CONFIG_TARGA_ENCODER 0 ++#define CONFIG_TIFF_ENCODER 0 ++#define CONFIG_UTVIDEO_ENCODER 0 ++#define CONFIG_V210_ENCODER 0 ++#define CONFIG_V308_ENCODER 0 ++#define CONFIG_V408_ENCODER 0 ++#define CONFIG_V410_ENCODER 0 ++#define CONFIG_VC2_ENCODER 0 ++#define CONFIG_WRAPPED_AVFRAME_ENCODER 0 ++#define CONFIG_WMV1_ENCODER 0 ++#define CONFIG_WMV2_ENCODER 0 ++#define CONFIG_XBM_ENCODER 0 ++#define CONFIG_XFACE_ENCODER 0 ++#define CONFIG_XWD_ENCODER 0 ++#define CONFIG_Y41P_ENCODER 0 ++#define CONFIG_YUV4_ENCODER 0 ++#define CONFIG_ZLIB_ENCODER 0 ++#define CONFIG_ZMBV_ENCODER 0 ++#define CONFIG_AAC_ENCODER 0 ++#define CONFIG_AC3_ENCODER 0 ++#define CONFIG_AC3_FIXED_ENCODER 0 ++#define CONFIG_ALAC_ENCODER 0 ++#define CONFIG_APTX_ENCODER 0 ++#define CONFIG_APTX_HD_ENCODER 0 ++#define CONFIG_DCA_ENCODER 0 ++#define CONFIG_EAC3_ENCODER 0 ++#define CONFIG_FLAC_ENCODER 0 ++#define CONFIG_G723_1_ENCODER 0 ++#define CONFIG_MLP_ENCODER 0 ++#define CONFIG_MP2_ENCODER 0 ++#define CONFIG_MP2FIXED_ENCODER 0 ++#define CONFIG_NELLYMOSER_ENCODER 0 ++#define CONFIG_OPUS_ENCODER 0 ++#define CONFIG_RA_144_ENCODER 0 ++#define CONFIG_SBC_ENCODER 0 ++#define CONFIG_SONIC_ENCODER 0 ++#define CONFIG_SONIC_LS_ENCODER 0 ++#define CONFIG_TRUEHD_ENCODER 0 ++#define CONFIG_TTA_ENCODER 0 ++#define CONFIG_VORBIS_ENCODER 0 ++#define CONFIG_WAVPACK_ENCODER 0 ++#define CONFIG_WMAV1_ENCODER 0 ++#define CONFIG_WMAV2_ENCODER 0 ++#define CONFIG_PCM_ALAW_ENCODER 0 ++#define CONFIG_PCM_F32BE_ENCODER 0 ++#define CONFIG_PCM_F32LE_ENCODER 0 ++#define CONFIG_PCM_F64BE_ENCODER 0 ++#define CONFIG_PCM_F64LE_ENCODER 0 ++#define CONFIG_PCM_MULAW_ENCODER 0 ++#define CONFIG_PCM_S8_ENCODER 0 ++#define CONFIG_PCM_S8_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S16BE_ENCODER 0 ++#define CONFIG_PCM_S16BE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S16LE_ENCODER 0 ++#define CONFIG_PCM_S16LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S24BE_ENCODER 0 ++#define CONFIG_PCM_S24DAUD_ENCODER 0 ++#define CONFIG_PCM_S24LE_ENCODER 0 ++#define CONFIG_PCM_S24LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S32BE_ENCODER 0 ++#define CONFIG_PCM_S32LE_ENCODER 0 ++#define CONFIG_PCM_S32LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S64BE_ENCODER 0 ++#define CONFIG_PCM_S64LE_ENCODER 0 ++#define CONFIG_PCM_U8_ENCODER 0 ++#define CONFIG_PCM_U16BE_ENCODER 0 ++#define CONFIG_PCM_U16LE_ENCODER 0 ++#define CONFIG_PCM_U24BE_ENCODER 0 ++#define CONFIG_PCM_U24LE_ENCODER 0 ++#define CONFIG_PCM_U32BE_ENCODER 0 ++#define CONFIG_PCM_U32LE_ENCODER 0 ++#define CONFIG_PCM_VIDC_ENCODER 0 ++#define CONFIG_ROQ_DPCM_ENCODER 0 ++#define CONFIG_ADPCM_ADX_ENCODER 0 ++#define CONFIG_ADPCM_G722_ENCODER 0 ++#define CONFIG_ADPCM_G726_ENCODER 0 ++#define CONFIG_ADPCM_G726LE_ENCODER 0 ++#define CONFIG_ADPCM_IMA_QT_ENCODER 0 ++#define CONFIG_ADPCM_IMA_WAV_ENCODER 0 ++#define CONFIG_ADPCM_MS_ENCODER 0 ++#define CONFIG_ADPCM_SWF_ENCODER 0 ++#define CONFIG_ADPCM_YAMAHA_ENCODER 0 ++#define CONFIG_SSA_ENCODER 0 ++#define CONFIG_ASS_ENCODER 0 ++#define CONFIG_DVBSUB_ENCODER 0 ++#define CONFIG_DVDSUB_ENCODER 0 ++#define CONFIG_MOVTEXT_ENCODER 0 ++#define CONFIG_SRT_ENCODER 0 ++#define CONFIG_SUBRIP_ENCODER 0 ++#define CONFIG_TEXT_ENCODER 0 ++#define CONFIG_WEBVTT_ENCODER 0 ++#define CONFIG_XSUB_ENCODER 0 ++#define CONFIG_AAC_AT_ENCODER 0 ++#define CONFIG_ALAC_AT_ENCODER 0 ++#define CONFIG_ILBC_AT_ENCODER 0 ++#define CONFIG_PCM_ALAW_AT_ENCODER 0 ++#define CONFIG_PCM_MULAW_AT_ENCODER 0 ++#define CONFIG_LIBAOM_AV1_ENCODER 0 ++#define CONFIG_LIBCODEC2_ENCODER 0 ++#define CONFIG_LIBFDK_AAC_ENCODER 0 ++#define CONFIG_LIBGSM_ENCODER 0 ++#define CONFIG_LIBGSM_MS_ENCODER 0 ++#define CONFIG_LIBILBC_ENCODER 0 ++#define CONFIG_LIBMP3LAME_ENCODER 0 ++#define CONFIG_LIBOPENCORE_AMRNB_ENCODER 0 ++#define CONFIG_LIBOPENJPEG_ENCODER 0 ++#define CONFIG_LIBOPUS_ENCODER 0 ++#define CONFIG_LIBSHINE_ENCODER 0 ++#define CONFIG_LIBSPEEX_ENCODER 0 ++#define CONFIG_LIBTHEORA_ENCODER 0 ++#define CONFIG_LIBTWOLAME_ENCODER 0 ++#define CONFIG_LIBVO_AMRWBENC_ENCODER 0 ++#define CONFIG_LIBVORBIS_ENCODER 0 ++#define CONFIG_LIBVPX_VP8_ENCODER 0 ++#define CONFIG_LIBVPX_VP9_ENCODER 0 ++#define CONFIG_LIBWAVPACK_ENCODER 0 ++#define CONFIG_LIBWEBP_ANIM_ENCODER 0 ++#define CONFIG_LIBWEBP_ENCODER 0 ++#define CONFIG_LIBX262_ENCODER 0 ++#define CONFIG_LIBX264_ENCODER 0 ++#define CONFIG_LIBX264RGB_ENCODER 0 ++#define CONFIG_LIBX265_ENCODER 0 ++#define CONFIG_LIBXAVS_ENCODER 0 ++#define CONFIG_LIBXAVS2_ENCODER 0 ++#define CONFIG_LIBXVID_ENCODER 0 ++#define CONFIG_H263_V4L2M2M_ENCODER 0 ++#define CONFIG_LIBOPENH264_ENCODER 0 ++#define CONFIG_H264_AMF_ENCODER 0 ++#define CONFIG_H264_NVENC_ENCODER 0 ++#define CONFIG_H264_OMX_ENCODER 0 ++#define CONFIG_H264_QSV_ENCODER 0 ++#define CONFIG_H264_V4L2M2M_ENCODER 0 ++#define CONFIG_H264_VAAPI_ENCODER 0 ++#define CONFIG_H264_VIDEOTOOLBOX_ENCODER 0 ++#define CONFIG_NVENC_ENCODER 0 ++#define CONFIG_NVENC_H264_ENCODER 0 ++#define CONFIG_NVENC_HEVC_ENCODER 0 ++#define CONFIG_HEVC_AMF_ENCODER 0 ++#define CONFIG_HEVC_NVENC_ENCODER 0 ++#define CONFIG_HEVC_QSV_ENCODER 0 ++#define CONFIG_HEVC_V4L2M2M_ENCODER 0 ++#define CONFIG_HEVC_VAAPI_ENCODER 0 ++#define CONFIG_HEVC_VIDEOTOOLBOX_ENCODER 0 ++#define CONFIG_LIBKVAZAAR_ENCODER 0 ++#define CONFIG_MJPEG_QSV_ENCODER 0 ++#define CONFIG_MJPEG_VAAPI_ENCODER 0 ++#define CONFIG_MPEG2_QSV_ENCODER 0 ++#define CONFIG_MPEG2_VAAPI_ENCODER 0 ++#define CONFIG_MPEG4_V4L2M2M_ENCODER 0 ++#define CONFIG_VP8_V4L2M2M_ENCODER 0 ++#define CONFIG_VP8_VAAPI_ENCODER 0 ++#define CONFIG_VP9_VAAPI_ENCODER 0 ++#define CONFIG_H263_VAAPI_HWACCEL 0 ++#define CONFIG_H263_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_H264_D3D11VA_HWACCEL 0 ++#define CONFIG_H264_D3D11VA2_HWACCEL 0 ++#define CONFIG_H264_DXVA2_HWACCEL 0 ++#define CONFIG_H264_NVDEC_HWACCEL 0 ++#define CONFIG_H264_VAAPI_HWACCEL 0 ++#define CONFIG_H264_VDPAU_HWACCEL 0 ++#define CONFIG_H264_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_HEVC_D3D11VA_HWACCEL 0 ++#define CONFIG_HEVC_D3D11VA2_HWACCEL 0 ++#define CONFIG_HEVC_DXVA2_HWACCEL 0 ++#define CONFIG_HEVC_NVDEC_HWACCEL 0 ++#define CONFIG_HEVC_VAAPI_HWACCEL 0 ++#define CONFIG_HEVC_VDPAU_HWACCEL 0 ++#define CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MJPEG_NVDEC_HWACCEL 0 ++#define CONFIG_MJPEG_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG1_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG1_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MPEG1_XVMC_HWACCEL 0 ++#define CONFIG_MPEG2_D3D11VA_HWACCEL 0 ++#define CONFIG_MPEG2_D3D11VA2_HWACCEL 0 ++#define CONFIG_MPEG2_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG2_DXVA2_HWACCEL 0 ++#define CONFIG_MPEG2_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG2_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MPEG2_XVMC_HWACCEL 0 ++#define CONFIG_MPEG4_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG4_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG4_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_VC1_D3D11VA_HWACCEL 0 ++#define CONFIG_VC1_D3D11VA2_HWACCEL 0 ++#define CONFIG_VC1_DXVA2_HWACCEL 0 ++#define CONFIG_VC1_NVDEC_HWACCEL 0 ++#define CONFIG_VC1_VAAPI_HWACCEL 0 ++#define CONFIG_VC1_VDPAU_HWACCEL 0 ++#define CONFIG_VP8_NVDEC_HWACCEL 0 ++#define CONFIG_VP8_VAAPI_HWACCEL 0 ++#define CONFIG_VP9_D3D11VA_HWACCEL 0 ++#define CONFIG_VP9_D3D11VA2_HWACCEL 0 ++#define CONFIG_VP9_DXVA2_HWACCEL 0 ++#define CONFIG_VP9_NVDEC_HWACCEL 0 ++#define CONFIG_VP9_VAAPI_HWACCEL 0 ++#define CONFIG_WMV3_D3D11VA_HWACCEL 0 ++#define CONFIG_WMV3_D3D11VA2_HWACCEL 0 ++#define CONFIG_WMV3_DXVA2_HWACCEL 0 ++#define CONFIG_WMV3_NVDEC_HWACCEL 0 ++#define CONFIG_WMV3_VAAPI_HWACCEL 0 ++#define CONFIG_WMV3_VDPAU_HWACCEL 0 ++#define CONFIG_AAC_PARSER 1 ++#define CONFIG_AAC_LATM_PARSER 0 ++#define CONFIG_AC3_PARSER 0 ++#define CONFIG_ADX_PARSER 0 ++#define CONFIG_AV1_PARSER 0 ++#define CONFIG_AVS2_PARSER 0 ++#define CONFIG_BMP_PARSER 0 ++#define CONFIG_CAVSVIDEO_PARSER 0 ++#define CONFIG_COOK_PARSER 0 ++#define CONFIG_DCA_PARSER 0 ++#define CONFIG_DIRAC_PARSER 0 ++#define CONFIG_DNXHD_PARSER 0 ++#define CONFIG_DPX_PARSER 0 ++#define CONFIG_DVAUDIO_PARSER 0 ++#define CONFIG_DVBSUB_PARSER 0 ++#define CONFIG_DVDSUB_PARSER 0 ++#define CONFIG_DVD_NAV_PARSER 0 ++#define CONFIG_FLAC_PARSER 1 ++#define CONFIG_G729_PARSER 0 ++#define CONFIG_GSM_PARSER 1 ++#define CONFIG_H261_PARSER 0 ++#define CONFIG_H263_PARSER 1 ++#define CONFIG_H264_PARSER 1 ++#define CONFIG_HEVC_PARSER 0 ++#define CONFIG_MJPEG_PARSER 0 ++#define CONFIG_MLP_PARSER 0 ++#define CONFIG_MPEG4VIDEO_PARSER 1 ++#define CONFIG_MPEGAUDIO_PARSER 1 ++#define CONFIG_MPEGVIDEO_PARSER 0 ++#define CONFIG_OPUS_PARSER 1 ++#define CONFIG_PNG_PARSER 0 ++#define CONFIG_PNM_PARSER 0 ++#define CONFIG_RV30_PARSER 0 ++#define CONFIG_RV40_PARSER 0 ++#define CONFIG_SBC_PARSER 0 ++#define CONFIG_SIPR_PARSER 0 ++#define CONFIG_TAK_PARSER 0 ++#define CONFIG_VC1_PARSER 0 ++#define CONFIG_VORBIS_PARSER 1 ++#define CONFIG_VP3_PARSER 1 ++#define CONFIG_VP8_PARSER 1 ++#define CONFIG_VP9_PARSER 0 ++#define CONFIG_XMA_PARSER 0 ++#define CONFIG_ALSA_INDEV 0 ++#define CONFIG_ANDROID_CAMERA_INDEV 0 ++#define CONFIG_AVFOUNDATION_INDEV 0 ++#define CONFIG_BKTR_INDEV 0 ++#define CONFIG_DECKLINK_INDEV 0 ++#define CONFIG_LIBNDI_NEWTEK_INDEV 0 ++#define CONFIG_DSHOW_INDEV 0 ++#define CONFIG_FBDEV_INDEV 0 ++#define CONFIG_GDIGRAB_INDEV 0 ++#define CONFIG_IEC61883_INDEV 0 ++#define CONFIG_JACK_INDEV 0 ++#define CONFIG_KMSGRAB_INDEV 0 ++#define CONFIG_LAVFI_INDEV 0 ++#define CONFIG_OPENAL_INDEV 0 ++#define CONFIG_OSS_INDEV 0 ++#define CONFIG_PULSE_INDEV 0 ++#define CONFIG_SNDIO_INDEV 0 ++#define CONFIG_V4L2_INDEV 0 ++#define CONFIG_VFWCAP_INDEV 0 ++#define CONFIG_XCBGRAB_INDEV 0 ++#define CONFIG_LIBCDIO_INDEV 0 ++#define CONFIG_LIBDC1394_INDEV 0 ++#define CONFIG_ALSA_OUTDEV 0 ++#define CONFIG_CACA_OUTDEV 0 ++#define CONFIG_DECKLINK_OUTDEV 0 ++#define CONFIG_LIBNDI_NEWTEK_OUTDEV 0 ++#define CONFIG_FBDEV_OUTDEV 0 ++#define CONFIG_OPENGL_OUTDEV 0 ++#define CONFIG_OSS_OUTDEV 0 ++#define CONFIG_PULSE_OUTDEV 0 ++#define CONFIG_SDL2_OUTDEV 0 ++#define CONFIG_SNDIO_OUTDEV 0 ++#define CONFIG_V4L2_OUTDEV 0 ++#define CONFIG_XV_OUTDEV 0 ++#define CONFIG_ABENCH_FILTER 0 ++#define CONFIG_ACOMPRESSOR_FILTER 0 ++#define CONFIG_ACONTRAST_FILTER 0 ++#define CONFIG_ACOPY_FILTER 0 ++#define CONFIG_ACUE_FILTER 0 ++#define CONFIG_ACROSSFADE_FILTER 0 ++#define CONFIG_ACROSSOVER_FILTER 0 ++#define CONFIG_ACRUSHER_FILTER 0 ++#define CONFIG_ADECLICK_FILTER 0 ++#define CONFIG_ADECLIP_FILTER 0 ++#define CONFIG_ADELAY_FILTER 0 ++#define CONFIG_ADERIVATIVE_FILTER 0 ++#define CONFIG_AECHO_FILTER 0 ++#define CONFIG_AEMPHASIS_FILTER 0 ++#define CONFIG_AEVAL_FILTER 0 ++#define CONFIG_AFADE_FILTER 0 ++#define CONFIG_AFFTDN_FILTER 0 ++#define CONFIG_AFFTFILT_FILTER 0 ++#define CONFIG_AFIR_FILTER 0 ++#define CONFIG_AFORMAT_FILTER 0 ++#define CONFIG_AGATE_FILTER 0 ++#define CONFIG_AIIR_FILTER 0 ++#define CONFIG_AINTEGRAL_FILTER 0 ++#define CONFIG_AINTERLEAVE_FILTER 0 ++#define CONFIG_ALIMITER_FILTER 0 ++#define CONFIG_ALLPASS_FILTER 0 ++#define CONFIG_ALOOP_FILTER 0 ++#define CONFIG_AMERGE_FILTER 0 ++#define CONFIG_AMETADATA_FILTER 0 ++#define CONFIG_AMIX_FILTER 0 ++#define CONFIG_AMULTIPLY_FILTER 0 ++#define CONFIG_ANEQUALIZER_FILTER 0 ++#define CONFIG_ANULL_FILTER 0 ++#define CONFIG_APAD_FILTER 0 ++#define CONFIG_APERMS_FILTER 0 ++#define CONFIG_APHASER_FILTER 0 ++#define CONFIG_APULSATOR_FILTER 0 ++#define CONFIG_AREALTIME_FILTER 0 ++#define CONFIG_ARESAMPLE_FILTER 0 ++#define CONFIG_AREVERSE_FILTER 0 ++#define CONFIG_ASELECT_FILTER 0 ++#define CONFIG_ASENDCMD_FILTER 0 ++#define CONFIG_ASETNSAMPLES_FILTER 0 ++#define CONFIG_ASETPTS_FILTER 0 ++#define CONFIG_ASETRATE_FILTER 0 ++#define CONFIG_ASETTB_FILTER 0 ++#define CONFIG_ASHOWINFO_FILTER 0 ++#define CONFIG_ASIDEDATA_FILTER 0 ++#define CONFIG_ASPLIT_FILTER 0 ++#define CONFIG_ASTATS_FILTER 0 ++#define CONFIG_ASTREAMSELECT_FILTER 0 ++#define CONFIG_ATEMPO_FILTER 0 ++#define CONFIG_ATRIM_FILTER 0 ++#define CONFIG_AZMQ_FILTER 0 ++#define CONFIG_BANDPASS_FILTER 0 ++#define CONFIG_BANDREJECT_FILTER 0 ++#define CONFIG_BASS_FILTER 0 ++#define CONFIG_BIQUAD_FILTER 0 ++#define CONFIG_BS2B_FILTER 0 ++#define CONFIG_CHANNELMAP_FILTER 0 ++#define CONFIG_CHANNELSPLIT_FILTER 0 ++#define CONFIG_CHORUS_FILTER 0 ++#define CONFIG_COMPAND_FILTER 0 ++#define CONFIG_COMPENSATIONDELAY_FILTER 0 ++#define CONFIG_CROSSFEED_FILTER 0 ++#define CONFIG_CRYSTALIZER_FILTER 0 ++#define CONFIG_DCSHIFT_FILTER 0 ++#define CONFIG_DRMETER_FILTER 0 ++#define CONFIG_DYNAUDNORM_FILTER 0 ++#define CONFIG_EARWAX_FILTER 0 ++#define CONFIG_EBUR128_FILTER 0 ++#define CONFIG_EQUALIZER_FILTER 0 ++#define CONFIG_EXTRASTEREO_FILTER 0 ++#define CONFIG_FIREQUALIZER_FILTER 0 ++#define CONFIG_FLANGER_FILTER 0 ++#define CONFIG_HAAS_FILTER 0 ++#define CONFIG_HDCD_FILTER 0 ++#define CONFIG_HEADPHONE_FILTER 0 ++#define CONFIG_HIGHPASS_FILTER 0 ++#define CONFIG_HIGHSHELF_FILTER 0 ++#define CONFIG_JOIN_FILTER 0 ++#define CONFIG_LADSPA_FILTER 0 ++#define CONFIG_LOUDNORM_FILTER 0 ++#define CONFIG_LOWPASS_FILTER 0 ++#define CONFIG_LOWSHELF_FILTER 0 ++#define CONFIG_LV2_FILTER 0 ++#define CONFIG_MCOMPAND_FILTER 0 ++#define CONFIG_PAN_FILTER 0 ++#define CONFIG_REPLAYGAIN_FILTER 0 ++#define CONFIG_RESAMPLE_FILTER 0 ++#define CONFIG_RUBBERBAND_FILTER 0 ++#define CONFIG_SIDECHAINCOMPRESS_FILTER 0 ++#define CONFIG_SIDECHAINGATE_FILTER 0 ++#define CONFIG_SILENCEDETECT_FILTER 0 ++#define CONFIG_SILENCEREMOVE_FILTER 0 ++#define CONFIG_SOFALIZER_FILTER 0 ++#define CONFIG_STEREOTOOLS_FILTER 0 ++#define CONFIG_STEREOWIDEN_FILTER 0 ++#define CONFIG_SUPEREQUALIZER_FILTER 0 ++#define CONFIG_SURROUND_FILTER 0 ++#define CONFIG_TREBLE_FILTER 0 ++#define CONFIG_TREMOLO_FILTER 0 ++#define CONFIG_VIBRATO_FILTER 0 ++#define CONFIG_VOLUME_FILTER 0 ++#define CONFIG_VOLUMEDETECT_FILTER 0 ++#define CONFIG_AEVALSRC_FILTER 0 ++#define CONFIG_ANOISESRC_FILTER 0 ++#define CONFIG_ANULLSRC_FILTER 0 ++#define CONFIG_FLITE_FILTER 0 ++#define CONFIG_HILBERT_FILTER 0 ++#define CONFIG_SINC_FILTER 0 ++#define CONFIG_SINE_FILTER 0 ++#define CONFIG_ANULLSINK_FILTER 0 ++#define CONFIG_ALPHAEXTRACT_FILTER 0 ++#define CONFIG_ALPHAMERGE_FILTER 0 ++#define CONFIG_AMPLIFY_FILTER 0 ++#define CONFIG_ASS_FILTER 0 ++#define CONFIG_ATADENOISE_FILTER 0 ++#define CONFIG_AVGBLUR_FILTER 0 ++#define CONFIG_AVGBLUR_OPENCL_FILTER 0 ++#define CONFIG_BBOX_FILTER 0 ++#define CONFIG_BENCH_FILTER 0 ++#define CONFIG_BITPLANENOISE_FILTER 0 ++#define CONFIG_BLACKDETECT_FILTER 0 ++#define CONFIG_BLACKFRAME_FILTER 0 ++#define CONFIG_BLEND_FILTER 0 ++#define CONFIG_BM3D_FILTER 0 ++#define CONFIG_BOXBLUR_FILTER 0 ++#define CONFIG_BOXBLUR_OPENCL_FILTER 0 ++#define CONFIG_BWDIF_FILTER 0 ++#define CONFIG_CHROMAHOLD_FILTER 0 ++#define CONFIG_CHROMAKEY_FILTER 0 ++#define CONFIG_CHROMASHIFT_FILTER 0 ++#define CONFIG_CIESCOPE_FILTER 0 ++#define CONFIG_CODECVIEW_FILTER 0 ++#define CONFIG_COLORBALANCE_FILTER 0 ++#define CONFIG_COLORCHANNELMIXER_FILTER 0 ++#define CONFIG_COLORKEY_FILTER 0 ++#define CONFIG_COLORLEVELS_FILTER 0 ++#define CONFIG_COLORMATRIX_FILTER 0 ++#define CONFIG_COLORSPACE_FILTER 0 ++#define CONFIG_CONVOLUTION_FILTER 0 ++#define CONFIG_CONVOLUTION_OPENCL_FILTER 0 ++#define CONFIG_CONVOLVE_FILTER 0 ++#define CONFIG_COPY_FILTER 0 ++#define CONFIG_COREIMAGE_FILTER 0 ++#define CONFIG_COVER_RECT_FILTER 0 ++#define CONFIG_CROP_FILTER 0 ++#define CONFIG_CROPDETECT_FILTER 0 ++#define CONFIG_CUE_FILTER 0 ++#define CONFIG_CURVES_FILTER 0 ++#define CONFIG_DATASCOPE_FILTER 0 ++#define CONFIG_DCTDNOIZ_FILTER 0 ++#define CONFIG_DEBAND_FILTER 0 ++#define CONFIG_DEBLOCK_FILTER 0 ++#define CONFIG_DECIMATE_FILTER 0 ++#define CONFIG_DECONVOLVE_FILTER 0 ++#define CONFIG_DEDOT_FILTER 0 ++#define CONFIG_DEFLATE_FILTER 0 ++#define CONFIG_DEFLICKER_FILTER 0 ++#define CONFIG_DEINTERLACE_QSV_FILTER 0 ++#define CONFIG_DEINTERLACE_VAAPI_FILTER 0 ++#define CONFIG_DEJUDDER_FILTER 0 ++#define CONFIG_DELOGO_FILTER 0 ++#define CONFIG_DENOISE_VAAPI_FILTER 0 ++#define CONFIG_DESHAKE_FILTER 0 ++#define CONFIG_DESPILL_FILTER 0 ++#define CONFIG_DETELECINE_FILTER 0 ++#define CONFIG_DILATION_FILTER 0 ++#define CONFIG_DILATION_OPENCL_FILTER 0 ++#define CONFIG_DISPLACE_FILTER 0 ++#define CONFIG_DOUBLEWEAVE_FILTER 0 ++#define CONFIG_DRAWBOX_FILTER 0 ++#define CONFIG_DRAWGRAPH_FILTER 0 ++#define CONFIG_DRAWGRID_FILTER 0 ++#define CONFIG_DRAWTEXT_FILTER 0 ++#define CONFIG_EDGEDETECT_FILTER 0 ++#define CONFIG_ELBG_FILTER 0 ++#define CONFIG_ENTROPY_FILTER 0 ++#define CONFIG_EQ_FILTER 0 ++#define CONFIG_EROSION_FILTER 0 ++#define CONFIG_EROSION_OPENCL_FILTER 0 ++#define CONFIG_EXTRACTPLANES_FILTER 0 ++#define CONFIG_FADE_FILTER 0 ++#define CONFIG_FFTDNOIZ_FILTER 0 ++#define CONFIG_FFTFILT_FILTER 0 ++#define CONFIG_FIELD_FILTER 0 ++#define CONFIG_FIELDHINT_FILTER 0 ++#define CONFIG_FIELDMATCH_FILTER 0 ++#define CONFIG_FIELDORDER_FILTER 0 ++#define CONFIG_FILLBORDERS_FILTER 0 ++#define CONFIG_FIND_RECT_FILTER 0 ++#define CONFIG_FLOODFILL_FILTER 0 ++#define CONFIG_FORMAT_FILTER 0 ++#define CONFIG_FPS_FILTER 0 ++#define CONFIG_FRAMEPACK_FILTER 0 ++#define CONFIG_FRAMERATE_FILTER 0 ++#define CONFIG_FRAMESTEP_FILTER 0 ++#define CONFIG_FREEZEDETECT_FILTER 0 ++#define CONFIG_FREI0R_FILTER 0 ++#define CONFIG_FSPP_FILTER 0 ++#define CONFIG_GBLUR_FILTER 0 ++#define CONFIG_GEQ_FILTER 0 ++#define CONFIG_GRADFUN_FILTER 0 ++#define CONFIG_GRAPHMONITOR_FILTER 0 ++#define CONFIG_GREYEDGE_FILTER 0 ++#define CONFIG_HALDCLUT_FILTER 0 ++#define CONFIG_HFLIP_FILTER 0 ++#define CONFIG_HISTEQ_FILTER 0 ++#define CONFIG_HISTOGRAM_FILTER 0 ++#define CONFIG_HQDN3D_FILTER 0 ++#define CONFIG_HQX_FILTER 0 ++#define CONFIG_HSTACK_FILTER 0 ++#define CONFIG_HUE_FILTER 0 ++#define CONFIG_HWDOWNLOAD_FILTER 0 ++#define CONFIG_HWMAP_FILTER 0 ++#define CONFIG_HWUPLOAD_FILTER 0 ++#define CONFIG_HWUPLOAD_CUDA_FILTER 0 ++#define CONFIG_HYSTERESIS_FILTER 0 ++#define CONFIG_IDET_FILTER 0 ++#define CONFIG_IL_FILTER 0 ++#define CONFIG_INFLATE_FILTER 0 ++#define CONFIG_INTERLACE_FILTER 0 ++#define CONFIG_INTERLEAVE_FILTER 0 ++#define CONFIG_KERNDEINT_FILTER 0 ++#define CONFIG_LENSCORRECTION_FILTER 0 ++#define CONFIG_LENSFUN_FILTER 0 ++#define CONFIG_LIBVMAF_FILTER 0 ++#define CONFIG_LIMITER_FILTER 0 ++#define CONFIG_LOOP_FILTER 0 ++#define CONFIG_LUMAKEY_FILTER 0 ++#define CONFIG_LUT_FILTER 0 ++#define CONFIG_LUT1D_FILTER 0 ++#define CONFIG_LUT2_FILTER 0 ++#define CONFIG_LUT3D_FILTER 0 ++#define CONFIG_LUTRGB_FILTER 0 ++#define CONFIG_LUTYUV_FILTER 0 ++#define CONFIG_MASKEDCLAMP_FILTER 0 ++#define CONFIG_MASKEDMERGE_FILTER 0 ++#define CONFIG_MCDEINT_FILTER 0 ++#define CONFIG_MERGEPLANES_FILTER 0 ++#define CONFIG_MESTIMATE_FILTER 0 ++#define CONFIG_METADATA_FILTER 0 ++#define CONFIG_MIDEQUALIZER_FILTER 0 ++#define CONFIG_MINTERPOLATE_FILTER 0 ++#define CONFIG_MIX_FILTER 0 ++#define CONFIG_MPDECIMATE_FILTER 0 ++#define CONFIG_NEGATE_FILTER 0 ++#define CONFIG_NLMEANS_FILTER 0 ++#define CONFIG_NNEDI_FILTER 0 ++#define CONFIG_NOFORMAT_FILTER 0 ++#define CONFIG_NOISE_FILTER 0 ++#define CONFIG_NORMALIZE_FILTER 0 ++#define CONFIG_NULL_FILTER 0 ++#define CONFIG_OCR_FILTER 0 ++#define CONFIG_OCV_FILTER 0 ++#define CONFIG_OSCILLOSCOPE_FILTER 0 ++#define CONFIG_OVERLAY_FILTER 0 ++#define CONFIG_OVERLAY_OPENCL_FILTER 0 ++#define CONFIG_OVERLAY_QSV_FILTER 0 ++#define CONFIG_OWDENOISE_FILTER 0 ++#define CONFIG_PAD_FILTER 0 ++#define CONFIG_PALETTEGEN_FILTER 0 ++#define CONFIG_PALETTEUSE_FILTER 0 ++#define CONFIG_PERMS_FILTER 0 ++#define CONFIG_PERSPECTIVE_FILTER 0 ++#define CONFIG_PHASE_FILTER 0 ++#define CONFIG_PIXDESCTEST_FILTER 0 ++#define CONFIG_PIXSCOPE_FILTER 0 ++#define CONFIG_PP_FILTER 0 ++#define CONFIG_PP7_FILTER 0 ++#define CONFIG_PREMULTIPLY_FILTER 0 ++#define CONFIG_PREWITT_FILTER 0 ++#define CONFIG_PREWITT_OPENCL_FILTER 0 ++#define CONFIG_PROCAMP_VAAPI_FILTER 0 ++#define CONFIG_PROGRAM_OPENCL_FILTER 0 ++#define CONFIG_PSEUDOCOLOR_FILTER 0 ++#define CONFIG_PSNR_FILTER 0 ++#define CONFIG_PULLUP_FILTER 0 ++#define CONFIG_QP_FILTER 0 ++#define CONFIG_RANDOM_FILTER 0 ++#define CONFIG_READEIA608_FILTER 0 ++#define CONFIG_READVITC_FILTER 0 ++#define CONFIG_REALTIME_FILTER 0 ++#define CONFIG_REMAP_FILTER 0 ++#define CONFIG_REMOVEGRAIN_FILTER 0 ++#define CONFIG_REMOVELOGO_FILTER 0 ++#define CONFIG_REPEATFIELDS_FILTER 0 ++#define CONFIG_REVERSE_FILTER 0 ++#define CONFIG_RGBASHIFT_FILTER 0 ++#define CONFIG_ROBERTS_FILTER 0 ++#define CONFIG_ROBERTS_OPENCL_FILTER 0 ++#define CONFIG_ROTATE_FILTER 0 ++#define CONFIG_SAB_FILTER 0 ++#define CONFIG_SCALE_FILTER 0 ++#define CONFIG_SCALE_CUDA_FILTER 0 ++#define CONFIG_SCALE_NPP_FILTER 0 ++#define CONFIG_SCALE_QSV_FILTER 0 ++#define CONFIG_SCALE_VAAPI_FILTER 0 ++#define CONFIG_SCALE2REF_FILTER 0 ++#define CONFIG_SELECT_FILTER 0 ++#define CONFIG_SELECTIVECOLOR_FILTER 0 ++#define CONFIG_SENDCMD_FILTER 0 ++#define CONFIG_SEPARATEFIELDS_FILTER 0 ++#define CONFIG_SETDAR_FILTER 0 ++#define CONFIG_SETFIELD_FILTER 0 ++#define CONFIG_SETPARAMS_FILTER 0 ++#define CONFIG_SETPTS_FILTER 0 ++#define CONFIG_SETRANGE_FILTER 0 ++#define CONFIG_SETSAR_FILTER 0 ++#define CONFIG_SETTB_FILTER 0 ++#define CONFIG_SHARPNESS_VAAPI_FILTER 0 ++#define CONFIG_SHOWINFO_FILTER 0 ++#define CONFIG_SHOWPALETTE_FILTER 0 ++#define CONFIG_SHUFFLEFRAMES_FILTER 0 ++#define CONFIG_SHUFFLEPLANES_FILTER 0 ++#define CONFIG_SIDEDATA_FILTER 0 ++#define CONFIG_SIGNALSTATS_FILTER 0 ++#define CONFIG_SIGNATURE_FILTER 0 ++#define CONFIG_SMARTBLUR_FILTER 0 ++#define CONFIG_SOBEL_FILTER 0 ++#define CONFIG_SOBEL_OPENCL_FILTER 0 ++#define CONFIG_SPLIT_FILTER 0 ++#define CONFIG_SPP_FILTER 0 ++#define CONFIG_SR_FILTER 0 ++#define CONFIG_SSIM_FILTER 0 ++#define CONFIG_STEREO3D_FILTER 0 ++#define CONFIG_STREAMSELECT_FILTER 0 ++#define CONFIG_SUBTITLES_FILTER 0 ++#define CONFIG_SUPER2XSAI_FILTER 0 ++#define CONFIG_SWAPRECT_FILTER 0 ++#define CONFIG_SWAPUV_FILTER 0 ++#define CONFIG_TBLEND_FILTER 0 ++#define CONFIG_TELECINE_FILTER 0 ++#define CONFIG_THRESHOLD_FILTER 0 ++#define CONFIG_THUMBNAIL_FILTER 0 ++#define CONFIG_THUMBNAIL_CUDA_FILTER 0 ++#define CONFIG_TILE_FILTER 0 ++#define CONFIG_TINTERLACE_FILTER 0 ++#define CONFIG_TLUT2_FILTER 0 ++#define CONFIG_TMIX_FILTER 0 ++#define CONFIG_TONEMAP_FILTER 0 ++#define CONFIG_TONEMAP_OPENCL_FILTER 0 ++#define CONFIG_TPAD_FILTER 0 ++#define CONFIG_TRANSPOSE_FILTER 0 ++#define CONFIG_TRANSPOSE_NPP_FILTER 0 ++#define CONFIG_TRIM_FILTER 0 ++#define CONFIG_UNPREMULTIPLY_FILTER 0 ++#define CONFIG_UNSHARP_FILTER 0 ++#define CONFIG_UNSHARP_OPENCL_FILTER 0 ++#define CONFIG_USPP_FILTER 0 ++#define CONFIG_VAGUEDENOISER_FILTER 0 ++#define CONFIG_VECTORSCOPE_FILTER 0 ++#define CONFIG_VFLIP_FILTER 0 ++#define CONFIG_VFRDET_FILTER 0 ++#define CONFIG_VIBRANCE_FILTER 0 ++#define CONFIG_VIDSTABDETECT_FILTER 0 ++#define CONFIG_VIDSTABTRANSFORM_FILTER 0 ++#define CONFIG_VIGNETTE_FILTER 0 ++#define CONFIG_VMAFMOTION_FILTER 0 ++#define CONFIG_VPP_QSV_FILTER 0 ++#define CONFIG_VSTACK_FILTER 0 ++#define CONFIG_W3FDIF_FILTER 0 ++#define CONFIG_WAVEFORM_FILTER 0 ++#define CONFIG_WEAVE_FILTER 0 ++#define CONFIG_XBR_FILTER 0 ++#define CONFIG_XSTACK_FILTER 0 ++#define CONFIG_YADIF_FILTER 0 ++#define CONFIG_YADIF_CUDA_FILTER 0 ++#define CONFIG_ZMQ_FILTER 0 ++#define CONFIG_ZOOMPAN_FILTER 0 ++#define CONFIG_ZSCALE_FILTER 0 ++#define CONFIG_ALLRGB_FILTER 0 ++#define CONFIG_ALLYUV_FILTER 0 ++#define CONFIG_CELLAUTO_FILTER 0 ++#define CONFIG_COLOR_FILTER 0 ++#define CONFIG_COREIMAGESRC_FILTER 0 ++#define CONFIG_FREI0R_SRC_FILTER 0 ++#define CONFIG_HALDCLUTSRC_FILTER 0 ++#define CONFIG_LIFE_FILTER 0 ++#define CONFIG_MANDELBROT_FILTER 0 ++#define CONFIG_MPTESTSRC_FILTER 0 ++#define CONFIG_NULLSRC_FILTER 0 ++#define CONFIG_OPENCLSRC_FILTER 0 ++#define CONFIG_PAL75BARS_FILTER 0 ++#define CONFIG_PAL100BARS_FILTER 0 ++#define CONFIG_RGBTESTSRC_FILTER 0 ++#define CONFIG_SMPTEBARS_FILTER 0 ++#define CONFIG_SMPTEHDBARS_FILTER 0 ++#define CONFIG_TESTSRC_FILTER 0 ++#define CONFIG_TESTSRC2_FILTER 0 ++#define CONFIG_YUVTESTSRC_FILTER 0 ++#define CONFIG_NULLSINK_FILTER 0 ++#define CONFIG_ABITSCOPE_FILTER 0 ++#define CONFIG_ADRAWGRAPH_FILTER 0 ++#define CONFIG_AGRAPHMONITOR_FILTER 0 ++#define CONFIG_AHISTOGRAM_FILTER 0 ++#define CONFIG_APHASEMETER_FILTER 0 ++#define CONFIG_AVECTORSCOPE_FILTER 0 ++#define CONFIG_CONCAT_FILTER 0 ++#define CONFIG_SHOWCQT_FILTER 0 ++#define CONFIG_SHOWFREQS_FILTER 0 ++#define CONFIG_SHOWSPECTRUM_FILTER 0 ++#define CONFIG_SHOWSPECTRUMPIC_FILTER 0 ++#define CONFIG_SHOWVOLUME_FILTER 0 ++#define CONFIG_SHOWWAVES_FILTER 0 ++#define CONFIG_SHOWWAVESPIC_FILTER 0 ++#define CONFIG_SPECTRUMSYNTH_FILTER 0 ++#define CONFIG_AMOVIE_FILTER 0 ++#define CONFIG_MOVIE_FILTER 0 ++#define CONFIG_AFIFO_FILTER 0 ++#define CONFIG_FIFO_FILTER 0 ++#define CONFIG_AA_DEMUXER 0 ++#define CONFIG_AAC_DEMUXER 1 ++#define CONFIG_AC3_DEMUXER 0 ++#define CONFIG_ACM_DEMUXER 0 ++#define CONFIG_ACT_DEMUXER 0 ++#define CONFIG_ADF_DEMUXER 0 ++#define CONFIG_ADP_DEMUXER 0 ++#define CONFIG_ADS_DEMUXER 0 ++#define CONFIG_ADX_DEMUXER 0 ++#define CONFIG_AEA_DEMUXER 0 ++#define CONFIG_AFC_DEMUXER 0 ++#define CONFIG_AIFF_DEMUXER 0 ++#define CONFIG_AIX_DEMUXER 0 ++#define CONFIG_AMR_DEMUXER 1 ++#define CONFIG_AMRNB_DEMUXER 0 ++#define CONFIG_AMRWB_DEMUXER 0 ++#define CONFIG_ANM_DEMUXER 0 ++#define CONFIG_APC_DEMUXER 0 ++#define CONFIG_APE_DEMUXER 0 ++#define CONFIG_APNG_DEMUXER 0 ++#define CONFIG_APTX_DEMUXER 0 ++#define CONFIG_APTX_HD_DEMUXER 0 ++#define CONFIG_AQTITLE_DEMUXER 0 ++#define CONFIG_ASF_DEMUXER 0 ++#define CONFIG_ASF_O_DEMUXER 0 ++#define CONFIG_ASS_DEMUXER 0 ++#define CONFIG_AST_DEMUXER 0 ++#define CONFIG_AU_DEMUXER 0 ++#define CONFIG_AVI_DEMUXER 1 ++#define CONFIG_AVISYNTH_DEMUXER 0 ++#define CONFIG_AVR_DEMUXER 0 ++#define CONFIG_AVS_DEMUXER 0 ++#define CONFIG_AVS2_DEMUXER 0 ++#define CONFIG_BETHSOFTVID_DEMUXER 0 ++#define CONFIG_BFI_DEMUXER 0 ++#define CONFIG_BINTEXT_DEMUXER 0 ++#define CONFIG_BINK_DEMUXER 0 ++#define CONFIG_BIT_DEMUXER 0 ++#define CONFIG_BMV_DEMUXER 0 ++#define CONFIG_BFSTM_DEMUXER 0 ++#define CONFIG_BRSTM_DEMUXER 0 ++#define CONFIG_BOA_DEMUXER 0 ++#define CONFIG_C93_DEMUXER 0 ++#define CONFIG_CAF_DEMUXER 0 ++#define CONFIG_CAVSVIDEO_DEMUXER 0 ++#define CONFIG_CDG_DEMUXER 0 ++#define CONFIG_CDXL_DEMUXER 0 ++#define CONFIG_CINE_DEMUXER 0 ++#define CONFIG_CODEC2_DEMUXER 0 ++#define CONFIG_CODEC2RAW_DEMUXER 0 ++#define CONFIG_CONCAT_DEMUXER 0 ++#define CONFIG_DASH_DEMUXER 0 ++#define CONFIG_DATA_DEMUXER 0 ++#define CONFIG_DAUD_DEMUXER 0 ++#define CONFIG_DCSTR_DEMUXER 0 ++#define CONFIG_DFA_DEMUXER 0 ++#define CONFIG_DHAV_DEMUXER 0 ++#define CONFIG_DIRAC_DEMUXER 0 ++#define CONFIG_DNXHD_DEMUXER 0 ++#define CONFIG_DSF_DEMUXER 0 ++#define CONFIG_DSICIN_DEMUXER 0 ++#define CONFIG_DSS_DEMUXER 0 ++#define CONFIG_DTS_DEMUXER 0 ++#define CONFIG_DTSHD_DEMUXER 0 ++#define CONFIG_DV_DEMUXER 0 ++#define CONFIG_DVBSUB_DEMUXER 0 ++#define CONFIG_DVBTXT_DEMUXER 0 ++#define CONFIG_DXA_DEMUXER 0 ++#define CONFIG_EA_DEMUXER 0 ++#define CONFIG_EA_CDATA_DEMUXER 0 ++#define CONFIG_EAC3_DEMUXER 0 ++#define CONFIG_EPAF_DEMUXER 0 ++#define CONFIG_FFMETADATA_DEMUXER 0 ++#define CONFIG_FILMSTRIP_DEMUXER 0 ++#define CONFIG_FITS_DEMUXER 0 ++#define CONFIG_FLAC_DEMUXER 1 ++#define CONFIG_FLIC_DEMUXER 0 ++#define CONFIG_FLV_DEMUXER 0 ++#define CONFIG_LIVE_FLV_DEMUXER 0 ++#define CONFIG_FOURXM_DEMUXER 0 ++#define CONFIG_FRM_DEMUXER 0 ++#define CONFIG_FSB_DEMUXER 0 ++#define CONFIG_G722_DEMUXER 0 ++#define CONFIG_G723_1_DEMUXER 0 ++#define CONFIG_G726_DEMUXER 0 ++#define CONFIG_G726LE_DEMUXER 0 ++#define CONFIG_G729_DEMUXER 0 ++#define CONFIG_GDV_DEMUXER 0 ++#define CONFIG_GENH_DEMUXER 0 ++#define CONFIG_GIF_DEMUXER 0 ++#define CONFIG_GSM_DEMUXER 0 ++#define CONFIG_GXF_DEMUXER 0 ++#define CONFIG_H261_DEMUXER 0 ++#define CONFIG_H263_DEMUXER 0 ++#define CONFIG_H264_DEMUXER 0 ++#define CONFIG_HEVC_DEMUXER 0 ++#define CONFIG_HLS_DEMUXER 0 ++#define CONFIG_HNM_DEMUXER 0 ++#define CONFIG_ICO_DEMUXER 0 ++#define CONFIG_IDCIN_DEMUXER 0 ++#define CONFIG_IDF_DEMUXER 0 ++#define CONFIG_IFF_DEMUXER 0 ++#define CONFIG_ILBC_DEMUXER 0 ++#define CONFIG_IMAGE2_DEMUXER 0 ++#define CONFIG_IMAGE2PIPE_DEMUXER 0 ++#define CONFIG_IMAGE2_ALIAS_PIX_DEMUXER 0 ++#define CONFIG_IMAGE2_BRENDER_PIX_DEMUXER 0 ++#define CONFIG_INGENIENT_DEMUXER 0 ++#define CONFIG_IPMOVIE_DEMUXER 0 ++#define CONFIG_IRCAM_DEMUXER 0 ++#define CONFIG_ISS_DEMUXER 0 ++#define CONFIG_IV8_DEMUXER 0 ++#define CONFIG_IVF_DEMUXER 0 ++#define CONFIG_IVR_DEMUXER 0 ++#define CONFIG_JACOSUB_DEMUXER 0 ++#define CONFIG_JV_DEMUXER 0 ++#define CONFIG_LMLM4_DEMUXER 0 ++#define CONFIG_LOAS_DEMUXER 0 ++#define CONFIG_LRC_DEMUXER 0 ++#define CONFIG_LVF_DEMUXER 0 ++#define CONFIG_LXF_DEMUXER 0 ++#define CONFIG_M4V_DEMUXER 0 ++#define CONFIG_MATROSKA_DEMUXER 1 ++#define CONFIG_MGSTS_DEMUXER 0 ++#define CONFIG_MICRODVD_DEMUXER 0 ++#define CONFIG_MJPEG_DEMUXER 0 ++#define CONFIG_MJPEG_2000_DEMUXER 0 ++#define CONFIG_MLP_DEMUXER 0 ++#define CONFIG_MLV_DEMUXER 0 ++#define CONFIG_MM_DEMUXER 0 ++#define CONFIG_MMF_DEMUXER 0 ++#define CONFIG_MOV_DEMUXER 1 ++#define CONFIG_MP3_DEMUXER 1 ++#define CONFIG_MPC_DEMUXER 0 ++#define CONFIG_MPC8_DEMUXER 0 ++#define CONFIG_MPEGPS_DEMUXER 0 ++#define CONFIG_MPEGTS_DEMUXER 0 ++#define CONFIG_MPEGTSRAW_DEMUXER 0 ++#define CONFIG_MPEGVIDEO_DEMUXER 0 ++#define CONFIG_MPJPEG_DEMUXER 0 ++#define CONFIG_MPL2_DEMUXER 0 ++#define CONFIG_MPSUB_DEMUXER 0 ++#define CONFIG_MSF_DEMUXER 0 ++#define CONFIG_MSNWC_TCP_DEMUXER 0 ++#define CONFIG_MTAF_DEMUXER 0 ++#define CONFIG_MTV_DEMUXER 0 ++#define CONFIG_MUSX_DEMUXER 0 ++#define CONFIG_MV_DEMUXER 0 ++#define CONFIG_MVI_DEMUXER 0 ++#define CONFIG_MXF_DEMUXER 0 ++#define CONFIG_MXG_DEMUXER 0 ++#define CONFIG_NC_DEMUXER 0 ++#define CONFIG_NISTSPHERE_DEMUXER 0 ++#define CONFIG_NSP_DEMUXER 0 ++#define CONFIG_NSV_DEMUXER 0 ++#define CONFIG_NUT_DEMUXER 0 ++#define CONFIG_NUV_DEMUXER 0 ++#define CONFIG_OGG_DEMUXER 1 ++#define CONFIG_OMA_DEMUXER 0 ++#define CONFIG_PAF_DEMUXER 0 ++#define CONFIG_PCM_ALAW_DEMUXER 0 ++#define CONFIG_PCM_MULAW_DEMUXER 0 ++#define CONFIG_PCM_VIDC_DEMUXER 0 ++#define CONFIG_PCM_F64BE_DEMUXER 0 ++#define CONFIG_PCM_F64LE_DEMUXER 0 ++#define CONFIG_PCM_F32BE_DEMUXER 0 ++#define CONFIG_PCM_F32LE_DEMUXER 0 ++#define CONFIG_PCM_S32BE_DEMUXER 0 ++#define CONFIG_PCM_S32LE_DEMUXER 0 ++#define CONFIG_PCM_S24BE_DEMUXER 0 ++#define CONFIG_PCM_S24LE_DEMUXER 0 ++#define CONFIG_PCM_S16BE_DEMUXER 0 ++#define CONFIG_PCM_S16LE_DEMUXER 0 ++#define CONFIG_PCM_S8_DEMUXER 0 ++#define CONFIG_PCM_U32BE_DEMUXER 0 ++#define CONFIG_PCM_U32LE_DEMUXER 0 ++#define CONFIG_PCM_U24BE_DEMUXER 0 ++#define CONFIG_PCM_U24LE_DEMUXER 0 ++#define CONFIG_PCM_U16BE_DEMUXER 0 ++#define CONFIG_PCM_U16LE_DEMUXER 0 ++#define CONFIG_PCM_U8_DEMUXER 0 ++#define CONFIG_PJS_DEMUXER 0 ++#define CONFIG_PMP_DEMUXER 0 ++#define CONFIG_PVA_DEMUXER 0 ++#define CONFIG_PVF_DEMUXER 0 ++#define CONFIG_QCP_DEMUXER 0 ++#define CONFIG_R3D_DEMUXER 0 ++#define CONFIG_RAWVIDEO_DEMUXER 0 ++#define CONFIG_REALTEXT_DEMUXER 0 ++#define CONFIG_REDSPARK_DEMUXER 0 ++#define CONFIG_RL2_DEMUXER 0 ++#define CONFIG_RM_DEMUXER 0 ++#define CONFIG_ROQ_DEMUXER 0 ++#define CONFIG_RPL_DEMUXER 0 ++#define CONFIG_RSD_DEMUXER 0 ++#define CONFIG_RSO_DEMUXER 0 ++#define CONFIG_RTP_DEMUXER 0 ++#define CONFIG_RTSP_DEMUXER 0 ++#define CONFIG_S337M_DEMUXER 0 ++#define CONFIG_SAMI_DEMUXER 0 ++#define CONFIG_SAP_DEMUXER 0 ++#define CONFIG_SBC_DEMUXER 0 ++#define CONFIG_SBG_DEMUXER 0 ++#define CONFIG_SCC_DEMUXER 0 ++#define CONFIG_SDP_DEMUXER 0 ++#define CONFIG_SDR2_DEMUXER 0 ++#define CONFIG_SDS_DEMUXER 0 ++#define CONFIG_SDX_DEMUXER 0 ++#define CONFIG_SEGAFILM_DEMUXER 0 ++#define CONFIG_SER_DEMUXER 0 ++#define CONFIG_SHORTEN_DEMUXER 0 ++#define CONFIG_SIFF_DEMUXER 0 ++#define CONFIG_SLN_DEMUXER 0 ++#define CONFIG_SMACKER_DEMUXER 0 ++#define CONFIG_SMJPEG_DEMUXER 0 ++#define CONFIG_SMUSH_DEMUXER 0 ++#define CONFIG_SOL_DEMUXER 0 ++#define CONFIG_SOX_DEMUXER 0 ++#define CONFIG_SPDIF_DEMUXER 0 ++#define CONFIG_SRT_DEMUXER 0 ++#define CONFIG_STR_DEMUXER 0 ++#define CONFIG_STL_DEMUXER 0 ++#define CONFIG_SUBVIEWER1_DEMUXER 0 ++#define CONFIG_SUBVIEWER_DEMUXER 0 ++#define CONFIG_SUP_DEMUXER 0 ++#define CONFIG_SVAG_DEMUXER 0 ++#define CONFIG_SWF_DEMUXER 0 ++#define CONFIG_TAK_DEMUXER 0 ++#define CONFIG_TEDCAPTIONS_DEMUXER 0 ++#define CONFIG_THP_DEMUXER 0 ++#define CONFIG_THREEDOSTR_DEMUXER 0 ++#define CONFIG_TIERTEXSEQ_DEMUXER 0 ++#define CONFIG_TMV_DEMUXER 0 ++#define CONFIG_TRUEHD_DEMUXER 0 ++#define CONFIG_TTA_DEMUXER 0 ++#define CONFIG_TXD_DEMUXER 0 ++#define CONFIG_TTY_DEMUXER 0 ++#define CONFIG_TY_DEMUXER 0 ++#define CONFIG_V210_DEMUXER 0 ++#define CONFIG_V210X_DEMUXER 0 ++#define CONFIG_VAG_DEMUXER 0 ++#define CONFIG_VC1_DEMUXER 0 ++#define CONFIG_VC1T_DEMUXER 0 ++#define CONFIG_VIVO_DEMUXER 0 ++#define CONFIG_VMD_DEMUXER 0 ++#define CONFIG_VOBSUB_DEMUXER 0 ++#define CONFIG_VOC_DEMUXER 0 ++#define CONFIG_VPK_DEMUXER 0 ++#define CONFIG_VPLAYER_DEMUXER 0 ++#define CONFIG_VQF_DEMUXER 0 ++#define CONFIG_W64_DEMUXER 0 ++#define CONFIG_WAV_DEMUXER 1 ++#define CONFIG_WC3_DEMUXER 0 ++#define CONFIG_WEBM_DASH_MANIFEST_DEMUXER 0 ++#define CONFIG_WEBVTT_DEMUXER 0 ++#define CONFIG_WSAUD_DEMUXER 0 ++#define CONFIG_WSD_DEMUXER 0 ++#define CONFIG_WSVQA_DEMUXER 0 ++#define CONFIG_WTV_DEMUXER 0 ++#define CONFIG_WVE_DEMUXER 0 ++#define CONFIG_WV_DEMUXER 0 ++#define CONFIG_XA_DEMUXER 0 ++#define CONFIG_XBIN_DEMUXER 0 ++#define CONFIG_XMV_DEMUXER 0 ++#define CONFIG_XVAG_DEMUXER 0 ++#define CONFIG_XWMA_DEMUXER 0 ++#define CONFIG_YOP_DEMUXER 0 ++#define CONFIG_YUV4MPEGPIPE_DEMUXER 0 ++#define CONFIG_IMAGE_BMP_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_DDS_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_DPX_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_EXR_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_J2K_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_JPEG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_JPEGLS_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PAM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PBM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PCX_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PGMYUV_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PGM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PICTOR_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PNG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PPM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PSD_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_QDRAW_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SGI_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SVG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SUNRAST_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_TIFF_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_WEBP_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_XPM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_XWD_PIPE_DEMUXER 0 ++#define CONFIG_LIBGME_DEMUXER 0 ++#define CONFIG_LIBMODPLUG_DEMUXER 0 ++#define CONFIG_LIBOPENMPT_DEMUXER 0 ++#define CONFIG_VAPOURSYNTH_DEMUXER 0 ++#define CONFIG_A64_MUXER 0 ++#define CONFIG_AC3_MUXER 0 ++#define CONFIG_ADTS_MUXER 0 ++#define CONFIG_ADX_MUXER 0 ++#define CONFIG_AIFF_MUXER 0 ++#define CONFIG_AMR_MUXER 0 ++#define CONFIG_APNG_MUXER 0 ++#define CONFIG_APTX_MUXER 0 ++#define CONFIG_APTX_HD_MUXER 0 ++#define CONFIG_ASF_MUXER 0 ++#define CONFIG_ASS_MUXER 0 ++#define CONFIG_AST_MUXER 0 ++#define CONFIG_ASF_STREAM_MUXER 0 ++#define CONFIG_AU_MUXER 0 ++#define CONFIG_AVI_MUXER 0 ++#define CONFIG_AVM2_MUXER 0 ++#define CONFIG_AVS2_MUXER 0 ++#define CONFIG_BIT_MUXER 0 ++#define CONFIG_CAF_MUXER 0 ++#define CONFIG_CAVSVIDEO_MUXER 0 ++#define CONFIG_CODEC2_MUXER 0 ++#define CONFIG_CODEC2RAW_MUXER 0 ++#define CONFIG_CRC_MUXER 0 ++#define CONFIG_DASH_MUXER 0 ++#define CONFIG_DATA_MUXER 0 ++#define CONFIG_DAUD_MUXER 0 ++#define CONFIG_DIRAC_MUXER 0 ++#define CONFIG_DNXHD_MUXER 0 ++#define CONFIG_DTS_MUXER 0 ++#define CONFIG_DV_MUXER 0 ++#define CONFIG_EAC3_MUXER 0 ++#define CONFIG_F4V_MUXER 0 ++#define CONFIG_FFMETADATA_MUXER 0 ++#define CONFIG_FIFO_MUXER 0 ++#define CONFIG_FIFO_TEST_MUXER 0 ++#define CONFIG_FILMSTRIP_MUXER 0 ++#define CONFIG_FITS_MUXER 0 ++#define CONFIG_FLAC_MUXER 0 ++#define CONFIG_FLV_MUXER 0 ++#define CONFIG_FRAMECRC_MUXER 0 ++#define CONFIG_FRAMEHASH_MUXER 0 ++#define CONFIG_FRAMEMD5_MUXER 0 ++#define CONFIG_G722_MUXER 0 ++#define CONFIG_G723_1_MUXER 0 ++#define CONFIG_G726_MUXER 0 ++#define CONFIG_G726LE_MUXER 0 ++#define CONFIG_GIF_MUXER 0 ++#define CONFIG_GSM_MUXER 0 ++#define CONFIG_GXF_MUXER 0 ++#define CONFIG_H261_MUXER 0 ++#define CONFIG_H263_MUXER 0 ++#define CONFIG_H264_MUXER 0 ++#define CONFIG_HASH_MUXER 0 ++#define CONFIG_HDS_MUXER 0 ++#define CONFIG_HEVC_MUXER 0 ++#define CONFIG_HLS_MUXER 0 ++#define CONFIG_ICO_MUXER 0 ++#define CONFIG_ILBC_MUXER 0 ++#define CONFIG_IMAGE2_MUXER 0 ++#define CONFIG_IMAGE2PIPE_MUXER 0 ++#define CONFIG_IPOD_MUXER 0 ++#define CONFIG_IRCAM_MUXER 0 ++#define CONFIG_ISMV_MUXER 0 ++#define CONFIG_IVF_MUXER 0 ++#define CONFIG_JACOSUB_MUXER 0 ++#define CONFIG_LATM_MUXER 0 ++#define CONFIG_LRC_MUXER 0 ++#define CONFIG_M4V_MUXER 0 ++#define CONFIG_MD5_MUXER 0 ++#define CONFIG_MATROSKA_MUXER 0 ++#define CONFIG_MATROSKA_AUDIO_MUXER 0 ++#define CONFIG_MICRODVD_MUXER 0 ++#define CONFIG_MJPEG_MUXER 0 ++#define CONFIG_MLP_MUXER 0 ++#define CONFIG_MMF_MUXER 0 ++#define CONFIG_MOV_MUXER 0 ++#define CONFIG_MP2_MUXER 0 ++#define CONFIG_MP3_MUXER 0 ++#define CONFIG_MP4_MUXER 0 ++#define CONFIG_MPEG1SYSTEM_MUXER 0 ++#define CONFIG_MPEG1VCD_MUXER 0 ++#define CONFIG_MPEG1VIDEO_MUXER 0 ++#define CONFIG_MPEG2DVD_MUXER 0 ++#define CONFIG_MPEG2SVCD_MUXER 0 ++#define CONFIG_MPEG2VIDEO_MUXER 0 ++#define CONFIG_MPEG2VOB_MUXER 0 ++#define CONFIG_MPEGTS_MUXER 0 ++#define CONFIG_MPJPEG_MUXER 0 ++#define CONFIG_MXF_MUXER 0 ++#define CONFIG_MXF_D10_MUXER 0 ++#define CONFIG_MXF_OPATOM_MUXER 0 ++#define CONFIG_NULL_MUXER 0 ++#define CONFIG_NUT_MUXER 0 ++#define CONFIG_OGA_MUXER 0 ++#define CONFIG_OGG_MUXER 0 ++#define CONFIG_OGV_MUXER 0 ++#define CONFIG_OMA_MUXER 0 ++#define CONFIG_OPUS_MUXER 0 ++#define CONFIG_PCM_ALAW_MUXER 0 ++#define CONFIG_PCM_MULAW_MUXER 0 ++#define CONFIG_PCM_VIDC_MUXER 0 ++#define CONFIG_PCM_F64BE_MUXER 0 ++#define CONFIG_PCM_F64LE_MUXER 0 ++#define CONFIG_PCM_F32BE_MUXER 0 ++#define CONFIG_PCM_F32LE_MUXER 0 ++#define CONFIG_PCM_S32BE_MUXER 0 ++#define CONFIG_PCM_S32LE_MUXER 0 ++#define CONFIG_PCM_S24BE_MUXER 0 ++#define CONFIG_PCM_S24LE_MUXER 0 ++#define CONFIG_PCM_S16BE_MUXER 0 ++#define CONFIG_PCM_S16LE_MUXER 0 ++#define CONFIG_PCM_S8_MUXER 0 ++#define CONFIG_PCM_U32BE_MUXER 0 ++#define CONFIG_PCM_U32LE_MUXER 0 ++#define CONFIG_PCM_U24BE_MUXER 0 ++#define CONFIG_PCM_U24LE_MUXER 0 ++#define CONFIG_PCM_U16BE_MUXER 0 ++#define CONFIG_PCM_U16LE_MUXER 0 ++#define CONFIG_PCM_U8_MUXER 0 ++#define CONFIG_PSP_MUXER 0 ++#define CONFIG_RAWVIDEO_MUXER 0 ++#define CONFIG_RM_MUXER 0 ++#define CONFIG_ROQ_MUXER 0 ++#define CONFIG_RSO_MUXER 0 ++#define CONFIG_RTP_MUXER 0 ++#define CONFIG_RTP_MPEGTS_MUXER 0 ++#define CONFIG_RTSP_MUXER 0 ++#define CONFIG_SAP_MUXER 0 ++#define CONFIG_SBC_MUXER 0 ++#define CONFIG_SCC_MUXER 0 ++#define CONFIG_SEGAFILM_MUXER 0 ++#define CONFIG_SEGMENT_MUXER 0 ++#define CONFIG_STREAM_SEGMENT_MUXER 0 ++#define CONFIG_SINGLEJPEG_MUXER 0 ++#define CONFIG_SMJPEG_MUXER 0 ++#define CONFIG_SMOOTHSTREAMING_MUXER 0 ++#define CONFIG_SOX_MUXER 0 ++#define CONFIG_SPX_MUXER 0 ++#define CONFIG_SPDIF_MUXER 0 ++#define CONFIG_SRT_MUXER 0 ++#define CONFIG_SUP_MUXER 0 ++#define CONFIG_SWF_MUXER 0 ++#define CONFIG_TEE_MUXER 0 ++#define CONFIG_TG2_MUXER 0 ++#define CONFIG_TGP_MUXER 0 ++#define CONFIG_MKVTIMESTAMP_V2_MUXER 0 ++#define CONFIG_TRUEHD_MUXER 0 ++#define CONFIG_TTA_MUXER 0 ++#define CONFIG_UNCODEDFRAMECRC_MUXER 0 ++#define CONFIG_VC1_MUXER 0 ++#define CONFIG_VC1T_MUXER 0 ++#define CONFIG_VOC_MUXER 0 ++#define CONFIG_W64_MUXER 0 ++#define CONFIG_WAV_MUXER 0 ++#define CONFIG_WEBM_MUXER 0 ++#define CONFIG_WEBM_DASH_MANIFEST_MUXER 0 ++#define CONFIG_WEBM_CHUNK_MUXER 0 ++#define CONFIG_WEBP_MUXER 0 ++#define CONFIG_WEBVTT_MUXER 0 ++#define CONFIG_WTV_MUXER 0 ++#define CONFIG_WV_MUXER 0 ++#define CONFIG_YUV4MPEGPIPE_MUXER 0 ++#define CONFIG_CHROMAPRINT_MUXER 0 ++#define CONFIG_ASYNC_PROTOCOL 0 ++#define CONFIG_BLURAY_PROTOCOL 0 ++#define CONFIG_CACHE_PROTOCOL 0 ++#define CONFIG_CONCAT_PROTOCOL 0 ++#define CONFIG_CRYPTO_PROTOCOL 0 ++#define CONFIG_DATA_PROTOCOL 0 ++#define CONFIG_FFRTMPCRYPT_PROTOCOL 0 ++#define CONFIG_FFRTMPHTTP_PROTOCOL 0 ++#define CONFIG_FILE_PROTOCOL 0 ++#define CONFIG_FTP_PROTOCOL 0 ++#define CONFIG_GOPHER_PROTOCOL 0 ++#define CONFIG_HLS_PROTOCOL 0 ++#define CONFIG_HTTP_PROTOCOL 0 ++#define CONFIG_HTTPPROXY_PROTOCOL 0 ++#define CONFIG_HTTPS_PROTOCOL 0 ++#define CONFIG_ICECAST_PROTOCOL 0 ++#define CONFIG_MMSH_PROTOCOL 0 ++#define CONFIG_MMST_PROTOCOL 0 ++#define CONFIG_MD5_PROTOCOL 0 ++#define CONFIG_PIPE_PROTOCOL 0 ++#define CONFIG_PROMPEG_PROTOCOL 0 ++#define CONFIG_RTMP_PROTOCOL 0 ++#define CONFIG_RTMPE_PROTOCOL 0 ++#define CONFIG_RTMPS_PROTOCOL 0 ++#define CONFIG_RTMPT_PROTOCOL 0 ++#define CONFIG_RTMPTE_PROTOCOL 0 ++#define CONFIG_RTMPTS_PROTOCOL 0 ++#define CONFIG_RTP_PROTOCOL 0 ++#define CONFIG_SCTP_PROTOCOL 0 ++#define CONFIG_SRTP_PROTOCOL 0 ++#define CONFIG_SUBFILE_PROTOCOL 0 ++#define CONFIG_TEE_PROTOCOL 0 ++#define CONFIG_TCP_PROTOCOL 0 ++#define CONFIG_TLS_PROTOCOL 0 ++#define CONFIG_UDP_PROTOCOL 0 ++#define CONFIG_UDPLITE_PROTOCOL 0 ++#define CONFIG_UNIX_PROTOCOL 0 ++#define CONFIG_LIBRTMP_PROTOCOL 0 ++#define CONFIG_LIBRTMPE_PROTOCOL 0 ++#define CONFIG_LIBRTMPS_PROTOCOL 0 ++#define CONFIG_LIBRTMPT_PROTOCOL 0 ++#define CONFIG_LIBRTMPTE_PROTOCOL 0 ++#define CONFIG_LIBSRT_PROTOCOL 0 ++#define CONFIG_LIBSSH_PROTOCOL 0 ++#define CONFIG_LIBSMBCLIENT_PROTOCOL 0 ++#endif /* FFMPEG_CONFIG_H */ +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/bsf_list.c b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/bsf_list.c +new file mode 100644 +index 00000000000..d31ece942a7 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/bsf_list.c +@@ -0,0 +1,3 @@ ++static const AVBitStreamFilter * const bitstream_filters[] = { ++ &ff_null_bsf, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/codec_list.c b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/codec_list.c +new file mode 100644 +index 00000000000..8f4b18388c3 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/codec_list.c +@@ -0,0 +1,25 @@ ++static const AVCodec * const codec_list[] = { ++ &ff_h263_decoder, ++ &ff_h264_decoder, ++ &ff_mpeg4_decoder, ++ &ff_theora_decoder, ++ &ff_vp3_decoder, ++ &ff_vp8_decoder, ++ &ff_aac_decoder, ++ &ff_amrnb_decoder, ++ &ff_amrwb_decoder, ++ &ff_flac_decoder, ++ &ff_gsm_ms_decoder, ++ &ff_mp3_decoder, ++ &ff_vorbis_decoder, ++ &ff_pcm_alaw_decoder, ++ &ff_pcm_f32le_decoder, ++ &ff_pcm_mulaw_decoder, ++ &ff_pcm_s16be_decoder, ++ &ff_pcm_s16le_decoder, ++ &ff_pcm_s24be_decoder, ++ &ff_pcm_s24le_decoder, ++ &ff_pcm_s32le_decoder, ++ &ff_pcm_u8_decoder, ++ &ff_libopus_decoder, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/parser_list.c b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/parser_list.c +new file mode 100644 +index 00000000000..ecd24e12bce +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavcodec/parser_list.c +@@ -0,0 +1,13 @@ ++static const AVCodecParser * const parser_list[] = { ++ &ff_aac_parser, ++ &ff_flac_parser, ++ &ff_gsm_parser, ++ &ff_h263_parser, ++ &ff_h264_parser, ++ &ff_mpeg4video_parser, ++ &ff_mpegaudio_parser, ++ &ff_opus_parser, ++ &ff_vorbis_parser, ++ &ff_vp3_parser, ++ &ff_vp8_parser, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/demuxer_list.c b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/demuxer_list.c +new file mode 100644 +index 00000000000..0c96cf1ff7e +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/demuxer_list.c +@@ -0,0 +1,11 @@ ++static const AVInputFormat * const demuxer_list[] = { ++ &ff_aac_demuxer, ++ &ff_amr_demuxer, ++ &ff_avi_demuxer, ++ &ff_flac_demuxer, ++ &ff_matroska_demuxer, ++ &ff_mov_demuxer, ++ &ff_mp3_demuxer, ++ &ff_ogg_demuxer, ++ &ff_wav_demuxer, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/muxer_list.c b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/muxer_list.c +new file mode 100644 +index 00000000000..f36d9499c6f +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/muxer_list.c +@@ -0,0 +1,2 @@ ++static const AVOutputFormat * const muxer_list[] = { ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/protocol_list.c b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/protocol_list.c +new file mode 100644 +index 00000000000..247e1e4c3a2 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavformat/protocol_list.c +@@ -0,0 +1,2 @@ ++static const URLProtocol * const url_protocols[] = { ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavutil/avconfig.h b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavutil/avconfig.h +new file mode 100644 +index 00000000000..c289fbb551c +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavutil/avconfig.h +@@ -0,0 +1,6 @@ ++/* Generated by ffmpeg configure */ ++#ifndef AVUTIL_AVCONFIG_H ++#define AVUTIL_AVCONFIG_H ++#define AV_HAVE_BIGENDIAN 0 ++#define AV_HAVE_FAST_UNALIGNED 1 ++#endif /* AVUTIL_AVCONFIG_H */ +diff --git a/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavutil/ffversion.h b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavutil/ffversion.h +new file mode 100644 +index 00000000000..9d3dbe8cc2a +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/ChromeOS/linux/ppc64/libavutil/ffversion.h +@@ -0,0 +1,5 @@ ++/* Automatically generated by version.sh, do not manually edit! */ ++#ifndef AVUTIL_FFVERSION_H ++#define AVUTIL_FFVERSION_H ++#define FFMPEG_VERSION "git-2020-01-07-ccf3ef182a0" ++#endif /* AVUTIL_FFVERSION_H */ +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/config.h b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/config.h +new file mode 100644 +index 00000000000..ddd610a87e1 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/config.h +@@ -0,0 +1,2478 @@ ++/* Automatically generated by configure - do not modify! */ ++#ifndef FFMPEG_CONFIG_H ++#define FFMPEG_CONFIG_H ++/* #define FFMPEG_CONFIGURATION "--disable-everything --disable-all --disable-doc --disable-htmlpages --disable-manpages --disable-podpages --disable-txtpages --disable-static --enable-avcodec --enable-avformat --enable-avutil --enable-fft --enable-rdft --enable-static --enable-libopus --disable-debug --disable-bzlib --disable-error-resilience --disable-iconv --disable-lzo --disable-network --disable-schannel --disable-sdl2 --disable-symver --disable-xlib --disable-zlib --disable-securetransport --disable-faan --disable-alsa --disable-autodetect --enable-decoder='vorbis,libopus,flac' --enable-decoder='pcm_u8,pcm_s16le,pcm_s24le,pcm_s32le,pcm_f32le,mp3' --enable-decoder='pcm_s16be,pcm_s24be,pcm_mulaw,pcm_alaw' --enable-demuxer='ogg,matroska,wav,flac,mp3,mov' --enable-parser='opus,vorbis,flac,mpegaudio' --extra-cflags=-I/mnt/dan/qtwebengine/src/3rdparty/chromium/third_party/opus/src/include --disable-linux-perf --x86asmexe=nasm --optflags='\"-O2\"' --enable-decoder='theora,vp8' --enable-parser='vp3,vp8' --arch=ppc64le --extra-cflags='-mcpu=power9' --enable-pic --cc=clang --cxx=clang++ --ld=clang" -- elide long configuration string from binary */ ++#define FFMPEG_LICENSE "LGPL version 2.1 or later" ++#define CONFIG_THIS_YEAR 2018 ++#define FFMPEG_DATADIR "/usr/local/share/ffmpeg" ++#define AVCONV_DATADIR "/usr/local/share/ffmpeg" ++#define CC_IDENT "clang version 8.0.0 (Fedora 8.0.0-3.fc30)" ++#define av_restrict restrict ++#define EXTERN_PREFIX "" ++#define EXTERN_ASM ++#define BUILDSUF "" ++#define SLIBSUF ".so" ++#define HAVE_MMX2 HAVE_MMXEXT ++#define SWS_MAX_FILTER_SIZE 256 ++#define ARCH_AARCH64 0 ++#define ARCH_ALPHA 0 ++#define ARCH_ARM 0 ++#define ARCH_AVR32 0 ++#define ARCH_AVR32_AP 0 ++#define ARCH_AVR32_UC 0 ++#define ARCH_BFIN 0 ++#define ARCH_IA64 0 ++#define ARCH_M68K 0 ++#define ARCH_MIPS 0 ++#define ARCH_MIPS64 0 ++#define ARCH_PARISC 0 ++#define ARCH_PPC 1 ++#define ARCH_PPC64 1 ++#define ARCH_S390 0 ++#define ARCH_SH4 0 ++#define ARCH_SPARC 0 ++#define ARCH_SPARC64 0 ++#define ARCH_TILEGX 0 ++#define ARCH_TILEPRO 0 ++#define ARCH_TOMI 0 ++#define ARCH_X86 0 ++#define ARCH_X86_32 0 ++#define ARCH_X86_64 0 ++#define HAVE_ARMV5TE 0 ++#define HAVE_ARMV6 0 ++#define HAVE_ARMV6T2 0 ++#define HAVE_ARMV8 0 ++#define HAVE_NEON 0 ++#define HAVE_VFP 0 ++#define HAVE_VFPV3 0 ++#define HAVE_SETEND 0 ++#define HAVE_ALTIVEC 1 ++#define HAVE_DCBZL 1 ++#define HAVE_LDBRX 0 ++#define HAVE_POWER8 1 ++#define HAVE_PPC4XX 0 ++#define HAVE_VSX 1 ++#define HAVE_AESNI 0 ++#define HAVE_AMD3DNOW 0 ++#define HAVE_AMD3DNOWEXT 0 ++#define HAVE_AVX 0 ++#define HAVE_AVX2 0 ++#define HAVE_AVX512 0 ++#define HAVE_FMA3 0 ++#define HAVE_FMA4 0 ++#define HAVE_MMX 0 ++#define HAVE_MMXEXT 0 ++#define HAVE_SSE 0 ++#define HAVE_SSE2 0 ++#define HAVE_SSE3 0 ++#define HAVE_SSE4 0 ++#define HAVE_SSE42 0 ++#define HAVE_SSSE3 0 ++#define HAVE_XOP 0 ++#define HAVE_CPUNOP 0 ++#define HAVE_I686 0 ++#define HAVE_MIPSFPU 0 ++#define HAVE_MIPS32R2 0 ++#define HAVE_MIPS32R5 0 ++#define HAVE_MIPS64R2 0 ++#define HAVE_MIPS32R6 0 ++#define HAVE_MIPS64R6 0 ++#define HAVE_MIPSDSP 0 ++#define HAVE_MIPSDSPR2 0 ++#define HAVE_MSA 0 ++#define HAVE_LOONGSON2 0 ++#define HAVE_LOONGSON3 0 ++#define HAVE_MMI 0 ++#define HAVE_ARMV5TE_EXTERNAL 0 ++#define HAVE_ARMV6_EXTERNAL 0 ++#define HAVE_ARMV6T2_EXTERNAL 0 ++#define HAVE_ARMV8_EXTERNAL 0 ++#define HAVE_NEON_EXTERNAL 0 ++#define HAVE_VFP_EXTERNAL 0 ++#define HAVE_VFPV3_EXTERNAL 0 ++#define HAVE_SETEND_EXTERNAL 0 ++#define HAVE_ALTIVEC_EXTERNAL 0 ++#define HAVE_DCBZL_EXTERNAL 0 ++#define HAVE_LDBRX_EXTERNAL 0 ++#define HAVE_POWER8_EXTERNAL 0 ++#define HAVE_PPC4XX_EXTERNAL 0 ++#define HAVE_VSX_EXTERNAL 0 ++#define HAVE_AESNI_EXTERNAL 0 ++#define HAVE_AMD3DNOW_EXTERNAL 0 ++#define HAVE_AMD3DNOWEXT_EXTERNAL 0 ++#define HAVE_AVX_EXTERNAL 0 ++#define HAVE_AVX2_EXTERNAL 0 ++#define HAVE_AVX512_EXTERNAL 0 ++#define HAVE_FMA3_EXTERNAL 0 ++#define HAVE_FMA4_EXTERNAL 0 ++#define HAVE_MMX_EXTERNAL 0 ++#define HAVE_MMXEXT_EXTERNAL 0 ++#define HAVE_SSE_EXTERNAL 0 ++#define HAVE_SSE2_EXTERNAL 0 ++#define HAVE_SSE3_EXTERNAL 0 ++#define HAVE_SSE4_EXTERNAL 0 ++#define HAVE_SSE42_EXTERNAL 0 ++#define HAVE_SSSE3_EXTERNAL 0 ++#define HAVE_XOP_EXTERNAL 0 ++#define HAVE_CPUNOP_EXTERNAL 0 ++#define HAVE_I686_EXTERNAL 0 ++#define HAVE_MIPSFPU_EXTERNAL 0 ++#define HAVE_MIPS32R2_EXTERNAL 0 ++#define HAVE_MIPS32R5_EXTERNAL 0 ++#define HAVE_MIPS64R2_EXTERNAL 0 ++#define HAVE_MIPS32R6_EXTERNAL 0 ++#define HAVE_MIPS64R6_EXTERNAL 0 ++#define HAVE_MIPSDSP_EXTERNAL 0 ++#define HAVE_MIPSDSPR2_EXTERNAL 0 ++#define HAVE_MSA_EXTERNAL 0 ++#define HAVE_LOONGSON2_EXTERNAL 0 ++#define HAVE_LOONGSON3_EXTERNAL 0 ++#define HAVE_MMI_EXTERNAL 0 ++#define HAVE_ARMV5TE_INLINE 0 ++#define HAVE_ARMV6_INLINE 0 ++#define HAVE_ARMV6T2_INLINE 0 ++#define HAVE_ARMV8_INLINE 0 ++#define HAVE_NEON_INLINE 0 ++#define HAVE_VFP_INLINE 0 ++#define HAVE_VFPV3_INLINE 0 ++#define HAVE_SETEND_INLINE 0 ++#define HAVE_ALTIVEC_INLINE 0 ++#define HAVE_DCBZL_INLINE 0 ++#define HAVE_LDBRX_INLINE 0 ++#define HAVE_POWER8_INLINE 0 ++#define HAVE_PPC4XX_INLINE 0 ++#define HAVE_VSX_INLINE 0 ++#define HAVE_AESNI_INLINE 0 ++#define HAVE_AMD3DNOW_INLINE 0 ++#define HAVE_AMD3DNOWEXT_INLINE 0 ++#define HAVE_AVX_INLINE 0 ++#define HAVE_AVX2_INLINE 0 ++#define HAVE_AVX512_INLINE 0 ++#define HAVE_FMA3_INLINE 0 ++#define HAVE_FMA4_INLINE 0 ++#define HAVE_MMX_INLINE 0 ++#define HAVE_MMXEXT_INLINE 0 ++#define HAVE_SSE_INLINE 0 ++#define HAVE_SSE2_INLINE 0 ++#define HAVE_SSE3_INLINE 0 ++#define HAVE_SSE4_INLINE 0 ++#define HAVE_SSE42_INLINE 0 ++#define HAVE_SSSE3_INLINE 0 ++#define HAVE_XOP_INLINE 0 ++#define HAVE_CPUNOP_INLINE 0 ++#define HAVE_I686_INLINE 0 ++#define HAVE_MIPSFPU_INLINE 0 ++#define HAVE_MIPS32R2_INLINE 0 ++#define HAVE_MIPS32R5_INLINE 0 ++#define HAVE_MIPS64R2_INLINE 0 ++#define HAVE_MIPS32R6_INLINE 0 ++#define HAVE_MIPS64R6_INLINE 0 ++#define HAVE_MIPSDSP_INLINE 0 ++#define HAVE_MIPSDSPR2_INLINE 0 ++#define HAVE_MSA_INLINE 0 ++#define HAVE_LOONGSON2_INLINE 0 ++#define HAVE_LOONGSON3_INLINE 0 ++#define HAVE_MMI_INLINE 0 ++#define HAVE_ALIGNED_STACK 1 ++#define HAVE_FAST_64BIT 1 ++#define HAVE_FAST_CLZ 1 ++#define HAVE_FAST_CMOV 0 ++#define HAVE_LOCAL_ALIGNED 1 ++#define HAVE_SIMD_ALIGN_16 1 ++#define HAVE_SIMD_ALIGN_32 0 ++#define HAVE_SIMD_ALIGN_64 0 ++#define HAVE_ATOMIC_CAS_PTR 0 ++#define HAVE_MACHINE_RW_BARRIER 0 ++#define HAVE_MEMORYBARRIER 0 ++#define HAVE_MM_EMPTY 0 ++#define HAVE_RDTSC 0 ++#define HAVE_SEM_TIMEDWAIT 1 ++#define HAVE_SYNC_VAL_COMPARE_AND_SWAP 1 ++#define HAVE_CABS 0 ++#define HAVE_CEXP 0 ++#define HAVE_INLINE_ASM 1 ++#define HAVE_SYMVER 0 ++#define HAVE_X86ASM 0 ++#define HAVE_BIGENDIAN 0 ++#define HAVE_FAST_UNALIGNED 1 ++#define HAVE_ARPA_INET_H 0 ++#define HAVE_ASM_TYPES_H 1 ++#define HAVE_CDIO_PARANOIA_H 0 ++#define HAVE_CDIO_PARANOIA_PARANOIA_H 0 ++#define HAVE_CUDA_H 0 ++#define HAVE_DISPATCH_DISPATCH_H 0 ++#define HAVE_DEV_BKTR_IOCTL_BT848_H 0 ++#define HAVE_DEV_BKTR_IOCTL_METEOR_H 0 ++#define HAVE_DEV_IC_BT8XX_H 0 ++#define HAVE_DEV_VIDEO_BKTR_IOCTL_BT848_H 0 ++#define HAVE_DEV_VIDEO_METEOR_IOCTL_METEOR_H 0 ++#define HAVE_DIRECT_H 0 ++#define HAVE_DIRENT_H 1 ++#define HAVE_DXGIDEBUG_H 0 ++#define HAVE_DXVA_H 0 ++#define HAVE_ES2_GL_H 0 ++#define HAVE_GSM_H 0 ++#define HAVE_IO_H 0 ++#define HAVE_LINUX_PERF_EVENT_H 1 ++#define HAVE_MACHINE_IOCTL_BT848_H 0 ++#define HAVE_MACHINE_IOCTL_METEOR_H 0 ++#define HAVE_MALLOC_H 1 ++#define HAVE_OPENCV2_CORE_CORE_C_H 0 ++#define HAVE_OPENGL_GL3_H 0 ++#define HAVE_POLL_H 1 ++#define HAVE_SYS_PARAM_H 1 ++#define HAVE_SYS_RESOURCE_H 1 ++#define HAVE_SYS_SELECT_H 1 ++#define HAVE_SYS_SOUNDCARD_H 1 ++#define HAVE_SYS_TIME_H 1 ++#define HAVE_SYS_UN_H 1 ++#define HAVE_SYS_VIDEOIO_H 0 ++#define HAVE_TERMIOS_H 1 ++#define HAVE_UDPLITE_H 0 ++#define HAVE_UNISTD_H 1 ++#define HAVE_VALGRIND_VALGRIND_H 0 /* #define HAVE_VALGRIND_VALGRIND_H 1 -- forced to 0. See https://crbug.com/590440 */ ++#define HAVE_WINDOWS_H 0 ++#define HAVE_WINSOCK2_H 0 ++#define HAVE_INTRINSICS_NEON 0 ++#define HAVE_ATANF 1 ++#define HAVE_ATAN2F 1 ++#define HAVE_CBRT 1 ++#define HAVE_CBRTF 1 ++#define HAVE_COPYSIGN 1 ++#define HAVE_COSF 1 ++#define HAVE_ERF 1 ++#define HAVE_EXP2 1 ++#define HAVE_EXP2F 1 ++#define HAVE_EXPF 1 ++#define HAVE_HYPOT 1 ++#define HAVE_ISFINITE 1 ++#define HAVE_ISINF 1 ++#define HAVE_ISNAN 1 ++#define HAVE_LDEXPF 1 ++#define HAVE_LLRINT 1 ++#define HAVE_LLRINTF 1 ++#define HAVE_LOG2 1 ++#define HAVE_LOG2F 1 ++#define HAVE_LOG10F 1 ++#define HAVE_LRINT 1 ++#define HAVE_LRINTF 1 ++#define HAVE_POWF 1 ++#define HAVE_RINT 1 ++#define HAVE_ROUND 1 ++#define HAVE_ROUNDF 1 ++#define HAVE_SINF 1 ++#define HAVE_TRUNC 1 ++#define HAVE_TRUNCF 1 ++#define HAVE_DOS_PATHS 0 ++#define HAVE_LIBC_MSVCRT 0 ++#define HAVE_MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS 0 ++#define HAVE_SECTION_DATA_REL_RO 1 ++#define HAVE_THREADS 1 ++#define HAVE_UWP 0 ++#define HAVE_WINRT 0 ++#define HAVE_ACCESS 1 ++#define HAVE_ALIGNED_MALLOC 0 ++#define HAVE_ARC4RANDOM 0 ++#define HAVE_CLOCK_GETTIME 1 ++#define HAVE_CLOSESOCKET 0 ++#define HAVE_COMMANDLINETOARGVW 0 ++#define HAVE_FCNTL 1 ++#define HAVE_GETADDRINFO 0 ++#define HAVE_GETHRTIME 0 ++#define HAVE_GETOPT 1 ++#define HAVE_GETPROCESSAFFINITYMASK 0 ++#define HAVE_GETPROCESSMEMORYINFO 0 ++#define HAVE_GETPROCESSTIMES 0 ++#define HAVE_GETRUSAGE 1 ++#define HAVE_GETSYSTEMTIMEASFILETIME 0 ++#define HAVE_GETTIMEOFDAY 1 ++#define HAVE_GLOB 1 ++#define HAVE_GLXGETPROCADDRESS 0 ++#define HAVE_GMTIME_R 1 ++#define HAVE_INET_ATON 0 ++#define HAVE_ISATTY 1 ++#define HAVE_KBHIT 0 ++#define HAVE_LOCALTIME_R 1 ++#define HAVE_LSTAT 1 ++#define HAVE_LZO1X_999_COMPRESS 0 ++#define HAVE_MACH_ABSOLUTE_TIME 0 ++#define HAVE_MAPVIEWOFFILE 0 ++#define HAVE_MEMALIGN 1 ++#define HAVE_MKSTEMP 1 ++#define HAVE_MMAP 1 ++#define HAVE_MPROTECT 1 ++#define HAVE_NANOSLEEP 1 ++#define HAVE_PEEKNAMEDPIPE 0 ++#define HAVE_POSIX_MEMALIGN 1 ++#define HAVE_PTHREAD_CANCEL 1 ++#define HAVE_SCHED_GETAFFINITY 1 ++#define HAVE_SECITEMIMPORT 0 ++#define HAVE_SETCONSOLETEXTATTRIBUTE 0 ++#define HAVE_SETCONSOLECTRLHANDLER 0 ++#define HAVE_SETMODE 0 ++#define HAVE_SETRLIMIT 1 ++#define HAVE_SLEEP 0 ++#define HAVE_STRERROR_R 1 ++#define HAVE_SYSCONF 1 ++#define HAVE_SYSCTL 0 /* #define HAVE_SYSCTL 1 -- forced to 0 for Fuchsia */ ++#define HAVE_USLEEP 1 ++#define HAVE_UTGETOSTYPEFROMSTRING 0 ++#define HAVE_VIRTUALALLOC 0 ++#define HAVE_WGLGETPROCADDRESS 0 ++#define HAVE_BCRYPT 0 ++#define HAVE_VAAPI_DRM 0 ++#define HAVE_VAAPI_X11 0 ++#define HAVE_VDPAU_X11 0 ++#define HAVE_PTHREADS 1 ++#define HAVE_OS2THREADS 0 ++#define HAVE_W32THREADS 0 ++#define HAVE_AS_ARCH_DIRECTIVE 0 ++#define HAVE_AS_DN_DIRECTIVE 0 ++#define HAVE_AS_FPU_DIRECTIVE 0 ++#define HAVE_AS_FUNC 0 ++#define HAVE_AS_OBJECT_ARCH 0 ++#define HAVE_ASM_MOD_Q 0 ++#define HAVE_BLOCKS_EXTENSION 0 ++#define HAVE_EBP_AVAILABLE 0 ++#define HAVE_EBX_AVAILABLE 0 ++#define HAVE_GNU_AS 0 ++#define HAVE_GNU_WINDRES 0 ++#define HAVE_IBM_ASM 1 ++#define HAVE_INLINE_ASM_DIRECT_SYMBOL_REFS 0 ++#define HAVE_INLINE_ASM_LABELS 1 ++#define HAVE_INLINE_ASM_NONLOCAL_LABELS 1 ++#define HAVE_PRAGMA_DEPRECATED 1 ++#define HAVE_RSYNC_CONTIMEOUT 1 ++#define HAVE_SYMVER_ASM_LABEL 1 ++#define HAVE_SYMVER_GNU_ASM 1 ++#define HAVE_VFP_ARGS 0 ++#define HAVE_XFORM_ASM 1 ++#define HAVE_XMM_CLOBBERS 0 ++#define HAVE_KCMVIDEOCODECTYPE_HEVC 0 ++#define HAVE_SOCKLEN_T 0 ++#define HAVE_STRUCT_ADDRINFO 0 ++#define HAVE_STRUCT_GROUP_SOURCE_REQ 0 ++#define HAVE_STRUCT_IP_MREQ_SOURCE 0 ++#define HAVE_STRUCT_IPV6_MREQ 0 ++#define HAVE_STRUCT_MSGHDR_MSG_FLAGS 0 ++#define HAVE_STRUCT_POLLFD 0 ++#define HAVE_STRUCT_RUSAGE_RU_MAXRSS 1 ++#define HAVE_STRUCT_SCTP_EVENT_SUBSCRIBE 0 ++#define HAVE_STRUCT_SOCKADDR_IN6 0 ++#define HAVE_STRUCT_SOCKADDR_SA_LEN 0 ++#define HAVE_STRUCT_SOCKADDR_STORAGE 0 ++#define HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 1 ++#define HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE 0 ++#define HAVE_MAKEINFO 1 ++#define HAVE_MAKEINFO_HTML 1 ++#define HAVE_OPENCL_D3D11 0 ++#define HAVE_OPENCL_DRM_ARM 0 ++#define HAVE_OPENCL_DRM_BEIGNET 0 ++#define HAVE_OPENCL_DXVA2 0 ++#define HAVE_OPENCL_VAAPI_BEIGNET 0 ++#define HAVE_OPENCL_VAAPI_INTEL_MEDIA 0 ++#define HAVE_PERL 1 ++#define HAVE_POD2MAN 1 ++#define HAVE_TEXI2HTML 0 ++#define CONFIG_DOC 0 ++#define CONFIG_HTMLPAGES 0 ++#define CONFIG_MANPAGES 0 ++#define CONFIG_PODPAGES 0 ++#define CONFIG_TXTPAGES 0 ++#define CONFIG_AVIO_DIR_CMD_EXAMPLE 1 ++#define CONFIG_AVIO_READING_EXAMPLE 1 ++#define CONFIG_DECODE_AUDIO_EXAMPLE 1 ++#define CONFIG_DECODE_VIDEO_EXAMPLE 1 ++#define CONFIG_DEMUXING_DECODING_EXAMPLE 1 ++#define CONFIG_ENCODE_AUDIO_EXAMPLE 1 ++#define CONFIG_ENCODE_VIDEO_EXAMPLE 1 ++#define CONFIG_EXTRACT_MVS_EXAMPLE 1 ++#define CONFIG_FILTER_AUDIO_EXAMPLE 0 ++#define CONFIG_FILTERING_AUDIO_EXAMPLE 0 ++#define CONFIG_FILTERING_VIDEO_EXAMPLE 0 ++#define CONFIG_HTTP_MULTICLIENT_EXAMPLE 1 ++#define CONFIG_HW_DECODE_EXAMPLE 1 ++#define CONFIG_METADATA_EXAMPLE 1 ++#define CONFIG_MUXING_EXAMPLE 0 ++#define CONFIG_QSVDEC_EXAMPLE 0 ++#define CONFIG_REMUXING_EXAMPLE 1 ++#define CONFIG_RESAMPLING_AUDIO_EXAMPLE 0 ++#define CONFIG_SCALING_VIDEO_EXAMPLE 0 ++#define CONFIG_TRANSCODE_AAC_EXAMPLE 0 ++#define CONFIG_TRANSCODING_EXAMPLE 0 ++#define CONFIG_VAAPI_ENCODE_EXAMPLE 0 ++#define CONFIG_VAAPI_TRANSCODE_EXAMPLE 0 ++#define CONFIG_AVISYNTH 0 ++#define CONFIG_FREI0R 0 ++#define CONFIG_LIBCDIO 0 ++#define CONFIG_LIBDAVS2 0 ++#define CONFIG_LIBRUBBERBAND 0 ++#define CONFIG_LIBVIDSTAB 0 ++#define CONFIG_LIBX264 0 ++#define CONFIG_LIBX265 0 ++#define CONFIG_LIBXAVS 0 ++#define CONFIG_LIBXAVS2 0 ++#define CONFIG_LIBXVID 0 ++#define CONFIG_DECKLINK 0 ++#define CONFIG_LIBNDI_NEWTEK 0 ++#define CONFIG_LIBFDK_AAC 0 ++#define CONFIG_OPENSSL 0 ++#define CONFIG_LIBTLS 0 ++#define CONFIG_GMP 0 ++#define CONFIG_LIBLENSFUN 0 ++#define CONFIG_LIBOPENCORE_AMRNB 0 ++#define CONFIG_LIBOPENCORE_AMRWB 0 ++#define CONFIG_LIBVMAF 0 ++#define CONFIG_LIBVO_AMRWBENC 0 ++#define CONFIG_MBEDTLS 0 ++#define CONFIG_RKMPP 0 ++#define CONFIG_LIBSMBCLIENT 0 ++#define CONFIG_CHROMAPRINT 0 ++#define CONFIG_GCRYPT 0 ++#define CONFIG_GNUTLS 0 ++#define CONFIG_JNI 0 ++#define CONFIG_LADSPA 0 ++#define CONFIG_LIBAOM 0 ++#define CONFIG_LIBASS 0 ++#define CONFIG_LIBBLURAY 0 ++#define CONFIG_LIBBS2B 0 ++#define CONFIG_LIBCACA 0 ++#define CONFIG_LIBCELT 0 ++#define CONFIG_LIBCODEC2 0 ++#define CONFIG_LIBDAV1D 0 ++#define CONFIG_LIBDC1394 0 ++#define CONFIG_LIBDRM 0 ++#define CONFIG_LIBFLITE 0 ++#define CONFIG_LIBFONTCONFIG 0 ++#define CONFIG_LIBFREETYPE 0 ++#define CONFIG_LIBFRIBIDI 0 ++#define CONFIG_LIBGME 0 ++#define CONFIG_LIBGSM 0 ++#define CONFIG_LIBIEC61883 0 ++#define CONFIG_LIBILBC 0 ++#define CONFIG_LIBJACK 0 ++#define CONFIG_LIBKLVANC 0 ++#define CONFIG_LIBKVAZAAR 0 ++#define CONFIG_LIBMODPLUG 0 ++#define CONFIG_LIBMP3LAME 0 ++#define CONFIG_LIBMYSOFA 0 ++#define CONFIG_LIBOPENCV 0 ++#define CONFIG_LIBOPENH264 0 ++#define CONFIG_LIBOPENJPEG 0 ++#define CONFIG_LIBOPENMPT 0 ++#define CONFIG_LIBOPUS 1 ++#define CONFIG_LIBPULSE 0 ++#define CONFIG_LIBRSVG 0 ++#define CONFIG_LIBRTMP 0 ++#define CONFIG_LIBSHINE 0 ++#define CONFIG_LIBSMBCLIENT 0 ++#define CONFIG_LIBSNAPPY 0 ++#define CONFIG_LIBSOXR 0 ++#define CONFIG_LIBSPEEX 0 ++#define CONFIG_LIBSRT 0 ++#define CONFIG_LIBSSH 0 ++#define CONFIG_LIBTENSORFLOW 0 ++#define CONFIG_LIBTESSERACT 0 ++#define CONFIG_LIBTHEORA 0 ++#define CONFIG_LIBTWOLAME 0 ++#define CONFIG_LIBV4L2 0 ++#define CONFIG_LIBVORBIS 0 ++#define CONFIG_LIBVPX 0 ++#define CONFIG_LIBWAVPACK 0 ++#define CONFIG_LIBWEBP 0 ++#define CONFIG_LIBXML2 0 ++#define CONFIG_LIBZIMG 0 ++#define CONFIG_LIBZMQ 0 ++#define CONFIG_LIBZVBI 0 ++#define CONFIG_LV2 0 ++#define CONFIG_MEDIACODEC 0 ++#define CONFIG_OPENAL 0 ++#define CONFIG_OPENGL 0 ++#define CONFIG_VAPOURSYNTH 0 ++#define CONFIG_ALSA 1 ++#define CONFIG_APPKIT 0 ++#define CONFIG_AVFOUNDATION 0 ++#define CONFIG_BZLIB 0 ++#define CONFIG_COREIMAGE 0 ++#define CONFIG_ICONV 0 ++#define CONFIG_LIBXCB 0 ++#define CONFIG_LIBXCB_SHM 0 ++#define CONFIG_LIBXCB_SHAPE 0 ++#define CONFIG_LIBXCB_XFIXES 0 ++#define CONFIG_LZMA 0 ++#define CONFIG_SCHANNEL 0 ++#define CONFIG_SDL2 0 ++#define CONFIG_SECURETRANSPORT 0 ++#define CONFIG_SNDIO 0 ++#define CONFIG_XLIB 0 ++#define CONFIG_ZLIB 0 ++#define CONFIG_CUDA_SDK 0 ++#define CONFIG_LIBNPP 0 ++#define CONFIG_LIBMFX 0 ++#define CONFIG_MMAL 0 ++#define CONFIG_OMX 0 ++#define CONFIG_OPENCL 0 ++#define CONFIG_AMF 0 ++#define CONFIG_AUDIOTOOLBOX 0 ++#define CONFIG_CRYSTALHD 0 ++#define CONFIG_CUDA 0 ++#define CONFIG_CUVID 0 ++#define CONFIG_D3D11VA 0 ++#define CONFIG_DXVA2 0 ++#define CONFIG_FFNVCODEC 0 ++#define CONFIG_NVDEC 0 ++#define CONFIG_NVENC 0 ++#define CONFIG_VAAPI 0 ++#define CONFIG_VDPAU 0 ++#define CONFIG_VIDEOTOOLBOX 0 ++#define CONFIG_V4L2_M2M 0 ++#define CONFIG_XVMC 0 ++#define CONFIG_FTRAPV 0 ++#define CONFIG_GRAY 0 ++#define CONFIG_HARDCODED_TABLES 0 ++#define CONFIG_OMX_RPI 0 ++#define CONFIG_RUNTIME_CPUDETECT 1 ++#define CONFIG_SAFE_BITSTREAM_READER 1 ++#define CONFIG_SHARED 0 ++#define CONFIG_SMALL 0 ++#define CONFIG_STATIC 1 ++#define CONFIG_SWSCALE_ALPHA 1 ++#define CONFIG_GPL 0 ++#define CONFIG_NONFREE 0 ++#define CONFIG_VERSION3 0 ++#define CONFIG_AVDEVICE 0 ++#define CONFIG_AVFILTER 0 ++#define CONFIG_SWSCALE 0 ++#define CONFIG_POSTPROC 0 ++#define CONFIG_AVFORMAT 1 ++#define CONFIG_AVCODEC 1 ++#define CONFIG_SWRESAMPLE 0 ++#define CONFIG_AVRESAMPLE 0 ++#define CONFIG_AVUTIL 1 ++#define CONFIG_FFPLAY 0 ++#define CONFIG_FFPROBE 0 ++#define CONFIG_FFMPEG 0 ++#define CONFIG_DCT 1 ++#define CONFIG_DWT 0 ++#define CONFIG_ERROR_RESILIENCE 0 ++#define CONFIG_FAAN 0 ++#define CONFIG_FAST_UNALIGNED 1 ++#define CONFIG_FFT 1 ++#define CONFIG_LSP 0 ++#define CONFIG_LZO 0 ++#define CONFIG_MDCT 1 ++#define CONFIG_PIXELUTILS 0 ++#define CONFIG_NETWORK 0 ++#define CONFIG_RDFT 1 ++#define CONFIG_AUTODETECT 0 ++#define CONFIG_FONTCONFIG 0 ++#define CONFIG_LINUX_PERF 0 ++#define CONFIG_MEMORY_POISONING 0 ++#define CONFIG_NEON_CLOBBER_TEST 0 ++#define CONFIG_OSSFUZZ 0 ++#define CONFIG_PIC 1 ++#define CONFIG_THUMB 0 ++#define CONFIG_VALGRIND_BACKTRACE 0 ++#define CONFIG_XMM_CLOBBER_TEST 0 ++#define CONFIG_BSFS 1 ++#define CONFIG_DECODERS 1 ++#define CONFIG_ENCODERS 0 ++#define CONFIG_HWACCELS 0 ++#define CONFIG_PARSERS 1 ++#define CONFIG_INDEVS 0 ++#define CONFIG_OUTDEVS 0 ++#define CONFIG_FILTERS 0 ++#define CONFIG_DEMUXERS 1 ++#define CONFIG_MUXERS 0 ++#define CONFIG_PROTOCOLS 0 ++#define CONFIG_AANDCTTABLES 0 ++#define CONFIG_AC3DSP 0 ++#define CONFIG_ADTS_HEADER 0 ++#define CONFIG_AUDIO_FRAME_QUEUE 0 ++#define CONFIG_AUDIODSP 0 ++#define CONFIG_BLOCKDSP 0 ++#define CONFIG_BSWAPDSP 0 ++#define CONFIG_CABAC 0 ++#define CONFIG_CBS 0 ++#define CONFIG_CBS_AV1 0 ++#define CONFIG_CBS_H264 0 ++#define CONFIG_CBS_H265 0 ++#define CONFIG_CBS_JPEG 0 ++#define CONFIG_CBS_MPEG2 0 ++#define CONFIG_CBS_VP9 0 ++#define CONFIG_DIRAC_PARSE 1 ++#define CONFIG_DNN 0 ++#define CONFIG_DVPROFILE 0 ++#define CONFIG_EXIF 0 ++#define CONFIG_FAANDCT 0 ++#define CONFIG_FAANIDCT 0 ++#define CONFIG_FDCTDSP 0 ++#define CONFIG_FLACDSP 1 ++#define CONFIG_FMTCONVERT 0 ++#define CONFIG_FRAME_THREAD_ENCODER 0 ++#define CONFIG_G722DSP 0 ++#define CONFIG_GOLOMB 1 ++#define CONFIG_GPLV3 0 ++#define CONFIG_H263DSP 0 ++#define CONFIG_H264CHROMA 0 ++#define CONFIG_H264DSP 0 ++#define CONFIG_H264PARSE 0 ++#define CONFIG_H264PRED 1 ++#define CONFIG_H264QPEL 0 ++#define CONFIG_HEVCPARSE 0 ++#define CONFIG_HPELDSP 1 ++#define CONFIG_HUFFMAN 0 ++#define CONFIG_HUFFYUVDSP 0 ++#define CONFIG_HUFFYUVENCDSP 0 ++#define CONFIG_IDCTDSP 0 ++#define CONFIG_IIRFILTER 0 ++#define CONFIG_MDCT15 0 ++#define CONFIG_INTRAX8 0 ++#define CONFIG_ISO_MEDIA 1 ++#define CONFIG_IVIDSP 0 ++#define CONFIG_JPEGTABLES 0 ++#define CONFIG_LGPLV3 0 ++#define CONFIG_LIBX262 0 ++#define CONFIG_LLAUDDSP 0 ++#define CONFIG_LLVIDDSP 0 ++#define CONFIG_LLVIDENCDSP 0 ++#define CONFIG_LPC 0 ++#define CONFIG_LZF 0 ++#define CONFIG_ME_CMP 0 ++#define CONFIG_MPEG_ER 0 ++#define CONFIG_MPEGAUDIO 1 ++#define CONFIG_MPEGAUDIODSP 1 ++#define CONFIG_MPEGAUDIOHEADER 1 ++#define CONFIG_MPEGVIDEO 0 ++#define CONFIG_MPEGVIDEOENC 0 ++#define CONFIG_MSS34DSP 0 ++#define CONFIG_PIXBLOCKDSP 0 ++#define CONFIG_QPELDSP 0 ++#define CONFIG_QSV 0 ++#define CONFIG_QSVDEC 0 ++#define CONFIG_QSVENC 0 ++#define CONFIG_QSVVPP 0 ++#define CONFIG_RANGECODER 0 ++#define CONFIG_RIFFDEC 1 ++#define CONFIG_RIFFENC 0 ++#define CONFIG_RTPDEC 0 ++#define CONFIG_RTPENC_CHAIN 0 ++#define CONFIG_RV34DSP 0 ++#define CONFIG_SCENE_SAD 0 ++#define CONFIG_SINEWIN 0 ++#define CONFIG_SNAPPY 0 ++#define CONFIG_SRTP 0 ++#define CONFIG_STARTCODE 0 ++#define CONFIG_TEXTUREDSP 0 ++#define CONFIG_TEXTUREDSPENC 0 ++#define CONFIG_TPELDSP 0 ++#define CONFIG_VAAPI_1 0 ++#define CONFIG_VAAPI_ENCODE 0 ++#define CONFIG_VC1DSP 0 ++#define CONFIG_VIDEODSP 1 ++#define CONFIG_VP3DSP 1 ++#define CONFIG_VP56DSP 0 ++#define CONFIG_VP8DSP 1 ++#define CONFIG_WMA_FREQS 0 ++#define CONFIG_WMV2DSP 0 ++#define CONFIG_AAC_ADTSTOASC_BSF 0 ++#define CONFIG_AV1_METADATA_BSF 0 ++#define CONFIG_CHOMP_BSF 0 ++#define CONFIG_DUMP_EXTRADATA_BSF 0 ++#define CONFIG_DCA_CORE_BSF 0 ++#define CONFIG_EAC3_CORE_BSF 0 ++#define CONFIG_EXTRACT_EXTRADATA_BSF 0 ++#define CONFIG_FILTER_UNITS_BSF 0 ++#define CONFIG_H264_METADATA_BSF 0 ++#define CONFIG_H264_MP4TOANNEXB_BSF 0 ++#define CONFIG_H264_REDUNDANT_PPS_BSF 0 ++#define CONFIG_HAPQA_EXTRACT_BSF 0 ++#define CONFIG_HEVC_METADATA_BSF 0 ++#define CONFIG_HEVC_MP4TOANNEXB_BSF 0 ++#define CONFIG_IMX_DUMP_HEADER_BSF 0 ++#define CONFIG_MJPEG2JPEG_BSF 0 ++#define CONFIG_MJPEGA_DUMP_HEADER_BSF 0 ++#define CONFIG_MP3_HEADER_DECOMPRESS_BSF 0 ++#define CONFIG_MPEG2_METADATA_BSF 0 ++#define CONFIG_MPEG4_UNPACK_BFRAMES_BSF 0 ++#define CONFIG_MOV2TEXTSUB_BSF 0 ++#define CONFIG_NOISE_BSF 0 ++#define CONFIG_NULL_BSF 1 ++#define CONFIG_PRORES_METADATA_BSF 0 ++#define CONFIG_REMOVE_EXTRADATA_BSF 0 ++#define CONFIG_TEXT2MOVSUB_BSF 0 ++#define CONFIG_TRACE_HEADERS_BSF 0 ++#define CONFIG_TRUEHD_CORE_BSF 0 ++#define CONFIG_VP9_METADATA_BSF 0 ++#define CONFIG_VP9_RAW_REORDER_BSF 0 ++#define CONFIG_VP9_SUPERFRAME_BSF 0 ++#define CONFIG_VP9_SUPERFRAME_SPLIT_BSF 0 ++#define CONFIG_AASC_DECODER 0 ++#define CONFIG_AIC_DECODER 0 ++#define CONFIG_ALIAS_PIX_DECODER 0 ++#define CONFIG_AMV_DECODER 0 ++#define CONFIG_ANM_DECODER 0 ++#define CONFIG_ANSI_DECODER 0 ++#define CONFIG_APNG_DECODER 0 ++#define CONFIG_ASV1_DECODER 0 ++#define CONFIG_ASV2_DECODER 0 ++#define CONFIG_AURA_DECODER 0 ++#define CONFIG_AURA2_DECODER 0 ++#define CONFIG_AVRP_DECODER 0 ++#define CONFIG_AVRN_DECODER 0 ++#define CONFIG_AVS_DECODER 0 ++#define CONFIG_AVUI_DECODER 0 ++#define CONFIG_AYUV_DECODER 0 ++#define CONFIG_BETHSOFTVID_DECODER 0 ++#define CONFIG_BFI_DECODER 0 ++#define CONFIG_BINK_DECODER 0 ++#define CONFIG_BITPACKED_DECODER 0 ++#define CONFIG_BMP_DECODER 0 ++#define CONFIG_BMV_VIDEO_DECODER 0 ++#define CONFIG_BRENDER_PIX_DECODER 0 ++#define CONFIG_C93_DECODER 0 ++#define CONFIG_CAVS_DECODER 0 ++#define CONFIG_CDGRAPHICS_DECODER 0 ++#define CONFIG_CDXL_DECODER 0 ++#define CONFIG_CFHD_DECODER 0 ++#define CONFIG_CINEPAK_DECODER 0 ++#define CONFIG_CLEARVIDEO_DECODER 0 ++#define CONFIG_CLJR_DECODER 0 ++#define CONFIG_CLLC_DECODER 0 ++#define CONFIG_COMFORTNOISE_DECODER 0 ++#define CONFIG_CPIA_DECODER 0 ++#define CONFIG_CSCD_DECODER 0 ++#define CONFIG_CYUV_DECODER 0 ++#define CONFIG_DDS_DECODER 0 ++#define CONFIG_DFA_DECODER 0 ++#define CONFIG_DIRAC_DECODER 0 ++#define CONFIG_DNXHD_DECODER 0 ++#define CONFIG_DPX_DECODER 0 ++#define CONFIG_DSICINVIDEO_DECODER 0 ++#define CONFIG_DVAUDIO_DECODER 0 ++#define CONFIG_DVVIDEO_DECODER 0 ++#define CONFIG_DXA_DECODER 0 ++#define CONFIG_DXTORY_DECODER 0 ++#define CONFIG_DXV_DECODER 0 ++#define CONFIG_EACMV_DECODER 0 ++#define CONFIG_EAMAD_DECODER 0 ++#define CONFIG_EATGQ_DECODER 0 ++#define CONFIG_EATGV_DECODER 0 ++#define CONFIG_EATQI_DECODER 0 ++#define CONFIG_EIGHTBPS_DECODER 0 ++#define CONFIG_EIGHTSVX_EXP_DECODER 0 ++#define CONFIG_EIGHTSVX_FIB_DECODER 0 ++#define CONFIG_ESCAPE124_DECODER 0 ++#define CONFIG_ESCAPE130_DECODER 0 ++#define CONFIG_EXR_DECODER 0 ++#define CONFIG_FFV1_DECODER 0 ++#define CONFIG_FFVHUFF_DECODER 0 ++#define CONFIG_FIC_DECODER 0 ++#define CONFIG_FITS_DECODER 0 ++#define CONFIG_FLASHSV_DECODER 0 ++#define CONFIG_FLASHSV2_DECODER 0 ++#define CONFIG_FLIC_DECODER 0 ++#define CONFIG_FLV_DECODER 0 ++#define CONFIG_FMVC_DECODER 0 ++#define CONFIG_FOURXM_DECODER 0 ++#define CONFIG_FRAPS_DECODER 0 ++#define CONFIG_FRWU_DECODER 0 ++#define CONFIG_G2M_DECODER 0 ++#define CONFIG_GDV_DECODER 0 ++#define CONFIG_GIF_DECODER 0 ++#define CONFIG_H261_DECODER 0 ++#define CONFIG_H263_DECODER 0 ++#define CONFIG_H263I_DECODER 0 ++#define CONFIG_H263P_DECODER 0 ++#define CONFIG_H263_V4L2M2M_DECODER 0 ++#define CONFIG_H264_DECODER 0 ++#define CONFIG_H264_CRYSTALHD_DECODER 0 ++#define CONFIG_H264_V4L2M2M_DECODER 0 ++#define CONFIG_H264_MEDIACODEC_DECODER 0 ++#define CONFIG_H264_MMAL_DECODER 0 ++#define CONFIG_H264_QSV_DECODER 0 ++#define CONFIG_H264_RKMPP_DECODER 0 ++#define CONFIG_HAP_DECODER 0 ++#define CONFIG_HEVC_DECODER 0 ++#define CONFIG_HEVC_QSV_DECODER 0 ++#define CONFIG_HEVC_RKMPP_DECODER 0 ++#define CONFIG_HEVC_V4L2M2M_DECODER 0 ++#define CONFIG_HNM4_VIDEO_DECODER 0 ++#define CONFIG_HQ_HQA_DECODER 0 ++#define CONFIG_HQX_DECODER 0 ++#define CONFIG_HUFFYUV_DECODER 0 ++#define CONFIG_IDCIN_DECODER 0 ++#define CONFIG_IFF_ILBM_DECODER 0 ++#define CONFIG_IMM4_DECODER 0 ++#define CONFIG_INDEO2_DECODER 0 ++#define CONFIG_INDEO3_DECODER 0 ++#define CONFIG_INDEO4_DECODER 0 ++#define CONFIG_INDEO5_DECODER 0 ++#define CONFIG_INTERPLAY_VIDEO_DECODER 0 ++#define CONFIG_JPEG2000_DECODER 0 ++#define CONFIG_JPEGLS_DECODER 0 ++#define CONFIG_JV_DECODER 0 ++#define CONFIG_KGV1_DECODER 0 ++#define CONFIG_KMVC_DECODER 0 ++#define CONFIG_LAGARITH_DECODER 0 ++#define CONFIG_LOCO_DECODER 0 ++#define CONFIG_M101_DECODER 0 ++#define CONFIG_MAGICYUV_DECODER 0 ++#define CONFIG_MDEC_DECODER 0 ++#define CONFIG_MIMIC_DECODER 0 ++#define CONFIG_MJPEG_DECODER 0 ++#define CONFIG_MJPEGB_DECODER 0 ++#define CONFIG_MMVIDEO_DECODER 0 ++#define CONFIG_MOTIONPIXELS_DECODER 0 ++#define CONFIG_MPEG1VIDEO_DECODER 0 ++#define CONFIG_MPEG2VIDEO_DECODER 0 ++#define CONFIG_MPEG4_DECODER 0 ++#define CONFIG_MPEG4_CRYSTALHD_DECODER 0 ++#define CONFIG_MPEG4_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG4_MMAL_DECODER 0 ++#define CONFIG_MPEGVIDEO_DECODER 0 ++#define CONFIG_MPEG1_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG2_MMAL_DECODER 0 ++#define CONFIG_MPEG2_CRYSTALHD_DECODER 0 ++#define CONFIG_MPEG2_V4L2M2M_DECODER 0 ++#define CONFIG_MPEG2_QSV_DECODER 0 ++#define CONFIG_MPEG2_MEDIACODEC_DECODER 0 ++#define CONFIG_MSA1_DECODER 0 ++#define CONFIG_MSCC_DECODER 0 ++#define CONFIG_MSMPEG4V1_DECODER 0 ++#define CONFIG_MSMPEG4V2_DECODER 0 ++#define CONFIG_MSMPEG4V3_DECODER 0 ++#define CONFIG_MSMPEG4_CRYSTALHD_DECODER 0 ++#define CONFIG_MSRLE_DECODER 0 ++#define CONFIG_MSS1_DECODER 0 ++#define CONFIG_MSS2_DECODER 0 ++#define CONFIG_MSVIDEO1_DECODER 0 ++#define CONFIG_MSZH_DECODER 0 ++#define CONFIG_MTS2_DECODER 0 ++#define CONFIG_MVC1_DECODER 0 ++#define CONFIG_MVC2_DECODER 0 ++#define CONFIG_MWSC_DECODER 0 ++#define CONFIG_MXPEG_DECODER 0 ++#define CONFIG_NUV_DECODER 0 ++#define CONFIG_PAF_VIDEO_DECODER 0 ++#define CONFIG_PAM_DECODER 0 ++#define CONFIG_PBM_DECODER 0 ++#define CONFIG_PCX_DECODER 0 ++#define CONFIG_PGM_DECODER 0 ++#define CONFIG_PGMYUV_DECODER 0 ++#define CONFIG_PICTOR_DECODER 0 ++#define CONFIG_PIXLET_DECODER 0 ++#define CONFIG_PNG_DECODER 0 ++#define CONFIG_PPM_DECODER 0 ++#define CONFIG_PRORES_DECODER 0 ++#define CONFIG_PROSUMER_DECODER 0 ++#define CONFIG_PSD_DECODER 0 ++#define CONFIG_PTX_DECODER 0 ++#define CONFIG_QDRAW_DECODER 0 ++#define CONFIG_QPEG_DECODER 0 ++#define CONFIG_QTRLE_DECODER 0 ++#define CONFIG_R10K_DECODER 0 ++#define CONFIG_R210_DECODER 0 ++#define CONFIG_RASC_DECODER 0 ++#define CONFIG_RAWVIDEO_DECODER 0 ++#define CONFIG_RL2_DECODER 0 ++#define CONFIG_ROQ_DECODER 0 ++#define CONFIG_RPZA_DECODER 0 ++#define CONFIG_RSCC_DECODER 0 ++#define CONFIG_RV10_DECODER 0 ++#define CONFIG_RV20_DECODER 0 ++#define CONFIG_RV30_DECODER 0 ++#define CONFIG_RV40_DECODER 0 ++#define CONFIG_S302M_DECODER 0 ++#define CONFIG_SANM_DECODER 0 ++#define CONFIG_SCPR_DECODER 0 ++#define CONFIG_SCREENPRESSO_DECODER 0 ++#define CONFIG_SDX2_DPCM_DECODER 0 ++#define CONFIG_SGI_DECODER 0 ++#define CONFIG_SGIRLE_DECODER 0 ++#define CONFIG_SHEERVIDEO_DECODER 0 ++#define CONFIG_SMACKER_DECODER 0 ++#define CONFIG_SMC_DECODER 0 ++#define CONFIG_SMVJPEG_DECODER 0 ++#define CONFIG_SNOW_DECODER 0 ++#define CONFIG_SP5X_DECODER 0 ++#define CONFIG_SPEEDHQ_DECODER 0 ++#define CONFIG_SRGC_DECODER 0 ++#define CONFIG_SUNRAST_DECODER 0 ++#define CONFIG_SVQ1_DECODER 0 ++#define CONFIG_SVQ3_DECODER 0 ++#define CONFIG_TARGA_DECODER 0 ++#define CONFIG_TARGA_Y216_DECODER 0 ++#define CONFIG_TDSC_DECODER 0 ++#define CONFIG_THEORA_DECODER 1 ++#define CONFIG_THP_DECODER 0 ++#define CONFIG_TIERTEXSEQVIDEO_DECODER 0 ++#define CONFIG_TIFF_DECODER 0 ++#define CONFIG_TMV_DECODER 0 ++#define CONFIG_TRUEMOTION1_DECODER 0 ++#define CONFIG_TRUEMOTION2_DECODER 0 ++#define CONFIG_TRUEMOTION2RT_DECODER 0 ++#define CONFIG_TSCC_DECODER 0 ++#define CONFIG_TSCC2_DECODER 0 ++#define CONFIG_TXD_DECODER 0 ++#define CONFIG_ULTI_DECODER 0 ++#define CONFIG_UTVIDEO_DECODER 0 ++#define CONFIG_V210_DECODER 0 ++#define CONFIG_V210X_DECODER 0 ++#define CONFIG_V308_DECODER 0 ++#define CONFIG_V408_DECODER 0 ++#define CONFIG_V410_DECODER 0 ++#define CONFIG_VB_DECODER 0 ++#define CONFIG_VBLE_DECODER 0 ++#define CONFIG_VC1_DECODER 0 ++#define CONFIG_VC1_CRYSTALHD_DECODER 0 ++#define CONFIG_VC1IMAGE_DECODER 0 ++#define CONFIG_VC1_MMAL_DECODER 0 ++#define CONFIG_VC1_QSV_DECODER 0 ++#define CONFIG_VC1_V4L2M2M_DECODER 0 ++#define CONFIG_VCR1_DECODER 0 ++#define CONFIG_VMDVIDEO_DECODER 0 ++#define CONFIG_VMNC_DECODER 0 ++#define CONFIG_VP3_DECODER 1 ++#define CONFIG_VP5_DECODER 0 ++#define CONFIG_VP6_DECODER 0 ++#define CONFIG_VP6A_DECODER 0 ++#define CONFIG_VP6F_DECODER 0 ++#define CONFIG_VP7_DECODER 0 ++#define CONFIG_VP8_DECODER 1 ++#define CONFIG_VP8_RKMPP_DECODER 0 ++#define CONFIG_VP8_V4L2M2M_DECODER 0 ++#define CONFIG_VP9_DECODER 0 ++#define CONFIG_VP9_RKMPP_DECODER 0 ++#define CONFIG_VP9_V4L2M2M_DECODER 0 ++#define CONFIG_VQA_DECODER 0 ++#define CONFIG_WEBP_DECODER 0 ++#define CONFIG_WCMV_DECODER 0 ++#define CONFIG_WRAPPED_AVFRAME_DECODER 0 ++#define CONFIG_WMV1_DECODER 0 ++#define CONFIG_WMV2_DECODER 0 ++#define CONFIG_WMV3_DECODER 0 ++#define CONFIG_WMV3_CRYSTALHD_DECODER 0 ++#define CONFIG_WMV3IMAGE_DECODER 0 ++#define CONFIG_WNV1_DECODER 0 ++#define CONFIG_XAN_WC3_DECODER 0 ++#define CONFIG_XAN_WC4_DECODER 0 ++#define CONFIG_XBM_DECODER 0 ++#define CONFIG_XFACE_DECODER 0 ++#define CONFIG_XL_DECODER 0 ++#define CONFIG_XPM_DECODER 0 ++#define CONFIG_XWD_DECODER 0 ++#define CONFIG_Y41P_DECODER 0 ++#define CONFIG_YLC_DECODER 0 ++#define CONFIG_YOP_DECODER 0 ++#define CONFIG_YUV4_DECODER 0 ++#define CONFIG_ZERO12V_DECODER 0 ++#define CONFIG_ZEROCODEC_DECODER 0 ++#define CONFIG_ZLIB_DECODER 0 ++#define CONFIG_ZMBV_DECODER 0 ++#define CONFIG_AAC_DECODER 0 ++#define CONFIG_AAC_FIXED_DECODER 0 ++#define CONFIG_AAC_LATM_DECODER 0 ++#define CONFIG_AC3_DECODER 0 ++#define CONFIG_AC3_FIXED_DECODER 0 ++#define CONFIG_ALAC_DECODER 0 ++#define CONFIG_ALS_DECODER 0 ++#define CONFIG_AMRNB_DECODER 0 ++#define CONFIG_AMRWB_DECODER 0 ++#define CONFIG_APE_DECODER 0 ++#define CONFIG_APTX_DECODER 0 ++#define CONFIG_APTX_HD_DECODER 0 ++#define CONFIG_ATRAC1_DECODER 0 ++#define CONFIG_ATRAC3_DECODER 0 ++#define CONFIG_ATRAC3AL_DECODER 0 ++#define CONFIG_ATRAC3P_DECODER 0 ++#define CONFIG_ATRAC3PAL_DECODER 0 ++#define CONFIG_ATRAC9_DECODER 0 ++#define CONFIG_BINKAUDIO_DCT_DECODER 0 ++#define CONFIG_BINKAUDIO_RDFT_DECODER 0 ++#define CONFIG_BMV_AUDIO_DECODER 0 ++#define CONFIG_COOK_DECODER 0 ++#define CONFIG_DCA_DECODER 0 ++#define CONFIG_DOLBY_E_DECODER 0 ++#define CONFIG_DSD_LSBF_DECODER 0 ++#define CONFIG_DSD_MSBF_DECODER 0 ++#define CONFIG_DSD_LSBF_PLANAR_DECODER 0 ++#define CONFIG_DSD_MSBF_PLANAR_DECODER 0 ++#define CONFIG_DSICINAUDIO_DECODER 0 ++#define CONFIG_DSS_SP_DECODER 0 ++#define CONFIG_DST_DECODER 0 ++#define CONFIG_EAC3_DECODER 0 ++#define CONFIG_EVRC_DECODER 0 ++#define CONFIG_FFWAVESYNTH_DECODER 0 ++#define CONFIG_FLAC_DECODER 1 ++#define CONFIG_G723_1_DECODER 0 ++#define CONFIG_G729_DECODER 0 ++#define CONFIG_GSM_DECODER 0 ++#define CONFIG_GSM_MS_DECODER 0 ++#define CONFIG_IAC_DECODER 0 ++#define CONFIG_ILBC_DECODER 0 ++#define CONFIG_IMC_DECODER 0 ++#define CONFIG_INTERPLAY_ACM_DECODER 0 ++#define CONFIG_MACE3_DECODER 0 ++#define CONFIG_MACE6_DECODER 0 ++#define CONFIG_METASOUND_DECODER 0 ++#define CONFIG_MLP_DECODER 0 ++#define CONFIG_MP1_DECODER 0 ++#define CONFIG_MP1FLOAT_DECODER 0 ++#define CONFIG_MP2_DECODER 0 ++#define CONFIG_MP2FLOAT_DECODER 0 ++#define CONFIG_MP3FLOAT_DECODER 0 ++#define CONFIG_MP3_DECODER 1 ++#define CONFIG_MP3ADUFLOAT_DECODER 0 ++#define CONFIG_MP3ADU_DECODER 0 ++#define CONFIG_MP3ON4FLOAT_DECODER 0 ++#define CONFIG_MP3ON4_DECODER 0 ++#define CONFIG_MPC7_DECODER 0 ++#define CONFIG_MPC8_DECODER 0 ++#define CONFIG_NELLYMOSER_DECODER 0 ++#define CONFIG_ON2AVC_DECODER 0 ++#define CONFIG_OPUS_DECODER 0 ++#define CONFIG_PAF_AUDIO_DECODER 0 ++#define CONFIG_QCELP_DECODER 0 ++#define CONFIG_QDM2_DECODER 0 ++#define CONFIG_QDMC_DECODER 0 ++#define CONFIG_RA_144_DECODER 0 ++#define CONFIG_RA_288_DECODER 0 ++#define CONFIG_RALF_DECODER 0 ++#define CONFIG_SBC_DECODER 0 ++#define CONFIG_SHORTEN_DECODER 0 ++#define CONFIG_SIPR_DECODER 0 ++#define CONFIG_SMACKAUD_DECODER 0 ++#define CONFIG_SONIC_DECODER 0 ++#define CONFIG_TAK_DECODER 0 ++#define CONFIG_TRUEHD_DECODER 0 ++#define CONFIG_TRUESPEECH_DECODER 0 ++#define CONFIG_TTA_DECODER 0 ++#define CONFIG_TWINVQ_DECODER 0 ++#define CONFIG_VMDAUDIO_DECODER 0 ++#define CONFIG_VORBIS_DECODER 1 ++#define CONFIG_WAVPACK_DECODER 0 ++#define CONFIG_WMALOSSLESS_DECODER 0 ++#define CONFIG_WMAPRO_DECODER 0 ++#define CONFIG_WMAV1_DECODER 0 ++#define CONFIG_WMAV2_DECODER 0 ++#define CONFIG_WMAVOICE_DECODER 0 ++#define CONFIG_WS_SND1_DECODER 0 ++#define CONFIG_XMA1_DECODER 0 ++#define CONFIG_XMA2_DECODER 0 ++#define CONFIG_PCM_ALAW_DECODER 1 ++#define CONFIG_PCM_BLURAY_DECODER 0 ++#define CONFIG_PCM_DVD_DECODER 0 ++#define CONFIG_PCM_F16LE_DECODER 0 ++#define CONFIG_PCM_F24LE_DECODER 0 ++#define CONFIG_PCM_F32BE_DECODER 0 ++#define CONFIG_PCM_F32LE_DECODER 1 ++#define CONFIG_PCM_F64BE_DECODER 0 ++#define CONFIG_PCM_F64LE_DECODER 0 ++#define CONFIG_PCM_LXF_DECODER 0 ++#define CONFIG_PCM_MULAW_DECODER 1 ++#define CONFIG_PCM_S8_DECODER 0 ++#define CONFIG_PCM_S8_PLANAR_DECODER 0 ++#define CONFIG_PCM_S16BE_DECODER 1 ++#define CONFIG_PCM_S16BE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S16LE_DECODER 1 ++#define CONFIG_PCM_S16LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S24BE_DECODER 1 ++#define CONFIG_PCM_S24DAUD_DECODER 0 ++#define CONFIG_PCM_S24LE_DECODER 1 ++#define CONFIG_PCM_S24LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S32BE_DECODER 0 ++#define CONFIG_PCM_S32LE_DECODER 1 ++#define CONFIG_PCM_S32LE_PLANAR_DECODER 0 ++#define CONFIG_PCM_S64BE_DECODER 0 ++#define CONFIG_PCM_S64LE_DECODER 0 ++#define CONFIG_PCM_U8_DECODER 1 ++#define CONFIG_PCM_U16BE_DECODER 0 ++#define CONFIG_PCM_U16LE_DECODER 0 ++#define CONFIG_PCM_U24BE_DECODER 0 ++#define CONFIG_PCM_U24LE_DECODER 0 ++#define CONFIG_PCM_U32BE_DECODER 0 ++#define CONFIG_PCM_U32LE_DECODER 0 ++#define CONFIG_PCM_VIDC_DECODER 0 ++#define CONFIG_PCM_ZORK_DECODER 0 ++#define CONFIG_GREMLIN_DPCM_DECODER 0 ++#define CONFIG_INTERPLAY_DPCM_DECODER 0 ++#define CONFIG_ROQ_DPCM_DECODER 0 ++#define CONFIG_SOL_DPCM_DECODER 0 ++#define CONFIG_XAN_DPCM_DECODER 0 ++#define CONFIG_ADPCM_4XM_DECODER 0 ++#define CONFIG_ADPCM_ADX_DECODER 0 ++#define CONFIG_ADPCM_AFC_DECODER 0 ++#define CONFIG_ADPCM_AICA_DECODER 0 ++#define CONFIG_ADPCM_CT_DECODER 0 ++#define CONFIG_ADPCM_DTK_DECODER 0 ++#define CONFIG_ADPCM_EA_DECODER 0 ++#define CONFIG_ADPCM_EA_MAXIS_XA_DECODER 0 ++#define CONFIG_ADPCM_EA_R1_DECODER 0 ++#define CONFIG_ADPCM_EA_R2_DECODER 0 ++#define CONFIG_ADPCM_EA_R3_DECODER 0 ++#define CONFIG_ADPCM_EA_XAS_DECODER 0 ++#define CONFIG_ADPCM_G722_DECODER 0 ++#define CONFIG_ADPCM_G726_DECODER 0 ++#define CONFIG_ADPCM_G726LE_DECODER 0 ++#define CONFIG_ADPCM_IMA_AMV_DECODER 0 ++#define CONFIG_ADPCM_IMA_APC_DECODER 0 ++#define CONFIG_ADPCM_IMA_DAT4_DECODER 0 ++#define CONFIG_ADPCM_IMA_DK3_DECODER 0 ++#define CONFIG_ADPCM_IMA_DK4_DECODER 0 ++#define CONFIG_ADPCM_IMA_EA_EACS_DECODER 0 ++#define CONFIG_ADPCM_IMA_EA_SEAD_DECODER 0 ++#define CONFIG_ADPCM_IMA_ISS_DECODER 0 ++#define CONFIG_ADPCM_IMA_OKI_DECODER 0 ++#define CONFIG_ADPCM_IMA_QT_DECODER 0 ++#define CONFIG_ADPCM_IMA_RAD_DECODER 0 ++#define CONFIG_ADPCM_IMA_SMJPEG_DECODER 0 ++#define CONFIG_ADPCM_IMA_WAV_DECODER 0 ++#define CONFIG_ADPCM_IMA_WS_DECODER 0 ++#define CONFIG_ADPCM_MS_DECODER 0 ++#define CONFIG_ADPCM_MTAF_DECODER 0 ++#define CONFIG_ADPCM_PSX_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_2_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_3_DECODER 0 ++#define CONFIG_ADPCM_SBPRO_4_DECODER 0 ++#define CONFIG_ADPCM_SWF_DECODER 0 ++#define CONFIG_ADPCM_THP_DECODER 0 ++#define CONFIG_ADPCM_THP_LE_DECODER 0 ++#define CONFIG_ADPCM_VIMA_DECODER 0 ++#define CONFIG_ADPCM_XA_DECODER 0 ++#define CONFIG_ADPCM_YAMAHA_DECODER 0 ++#define CONFIG_SSA_DECODER 0 ++#define CONFIG_ASS_DECODER 0 ++#define CONFIG_CCAPTION_DECODER 0 ++#define CONFIG_DVBSUB_DECODER 0 ++#define CONFIG_DVDSUB_DECODER 0 ++#define CONFIG_JACOSUB_DECODER 0 ++#define CONFIG_MICRODVD_DECODER 0 ++#define CONFIG_MOVTEXT_DECODER 0 ++#define CONFIG_MPL2_DECODER 0 ++#define CONFIG_PGSSUB_DECODER 0 ++#define CONFIG_PJS_DECODER 0 ++#define CONFIG_REALTEXT_DECODER 0 ++#define CONFIG_SAMI_DECODER 0 ++#define CONFIG_SRT_DECODER 0 ++#define CONFIG_STL_DECODER 0 ++#define CONFIG_SUBRIP_DECODER 0 ++#define CONFIG_SUBVIEWER_DECODER 0 ++#define CONFIG_SUBVIEWER1_DECODER 0 ++#define CONFIG_TEXT_DECODER 0 ++#define CONFIG_VPLAYER_DECODER 0 ++#define CONFIG_WEBVTT_DECODER 0 ++#define CONFIG_XSUB_DECODER 0 ++#define CONFIG_AAC_AT_DECODER 0 ++#define CONFIG_AC3_AT_DECODER 0 ++#define CONFIG_ADPCM_IMA_QT_AT_DECODER 0 ++#define CONFIG_ALAC_AT_DECODER 0 ++#define CONFIG_AMR_NB_AT_DECODER 0 ++#define CONFIG_EAC3_AT_DECODER 0 ++#define CONFIG_GSM_MS_AT_DECODER 0 ++#define CONFIG_ILBC_AT_DECODER 0 ++#define CONFIG_MP1_AT_DECODER 0 ++#define CONFIG_MP2_AT_DECODER 0 ++#define CONFIG_MP3_AT_DECODER 0 ++#define CONFIG_PCM_ALAW_AT_DECODER 0 ++#define CONFIG_PCM_MULAW_AT_DECODER 0 ++#define CONFIG_QDMC_AT_DECODER 0 ++#define CONFIG_QDM2_AT_DECODER 0 ++#define CONFIG_LIBAOM_AV1_DECODER 0 ++#define CONFIG_LIBCELT_DECODER 0 ++#define CONFIG_LIBCODEC2_DECODER 0 ++#define CONFIG_LIBDAV1D_DECODER 0 ++#define CONFIG_LIBDAVS2_DECODER 0 ++#define CONFIG_LIBFDK_AAC_DECODER 0 ++#define CONFIG_LIBGSM_DECODER 0 ++#define CONFIG_LIBGSM_MS_DECODER 0 ++#define CONFIG_LIBILBC_DECODER 0 ++#define CONFIG_LIBOPENCORE_AMRNB_DECODER 0 ++#define CONFIG_LIBOPENCORE_AMRWB_DECODER 0 ++#define CONFIG_LIBOPENJPEG_DECODER 0 ++#define CONFIG_LIBOPUS_DECODER 1 ++#define CONFIG_LIBRSVG_DECODER 0 ++#define CONFIG_LIBSPEEX_DECODER 0 ++#define CONFIG_LIBVORBIS_DECODER 0 ++#define CONFIG_LIBVPX_VP8_DECODER 0 ++#define CONFIG_LIBVPX_VP9_DECODER 0 ++#define CONFIG_LIBZVBI_TELETEXT_DECODER 0 ++#define CONFIG_BINTEXT_DECODER 0 ++#define CONFIG_XBIN_DECODER 0 ++#define CONFIG_IDF_DECODER 0 ++#define CONFIG_LIBOPENH264_DECODER 0 ++#define CONFIG_H264_CUVID_DECODER 0 ++#define CONFIG_HEVC_CUVID_DECODER 0 ++#define CONFIG_HEVC_MEDIACODEC_DECODER 0 ++#define CONFIG_MJPEG_CUVID_DECODER 0 ++#define CONFIG_MPEG1_CUVID_DECODER 0 ++#define CONFIG_MPEG2_CUVID_DECODER 0 ++#define CONFIG_MPEG4_CUVID_DECODER 0 ++#define CONFIG_MPEG4_MEDIACODEC_DECODER 0 ++#define CONFIG_VC1_CUVID_DECODER 0 ++#define CONFIG_VP8_CUVID_DECODER 0 ++#define CONFIG_VP8_MEDIACODEC_DECODER 0 ++#define CONFIG_VP8_QSV_DECODER 0 ++#define CONFIG_VP9_CUVID_DECODER 0 ++#define CONFIG_VP9_MEDIACODEC_DECODER 0 ++#define CONFIG_A64MULTI_ENCODER 0 ++#define CONFIG_A64MULTI5_ENCODER 0 ++#define CONFIG_ALIAS_PIX_ENCODER 0 ++#define CONFIG_AMV_ENCODER 0 ++#define CONFIG_APNG_ENCODER 0 ++#define CONFIG_ASV1_ENCODER 0 ++#define CONFIG_ASV2_ENCODER 0 ++#define CONFIG_AVRP_ENCODER 0 ++#define CONFIG_AVUI_ENCODER 0 ++#define CONFIG_AYUV_ENCODER 0 ++#define CONFIG_BMP_ENCODER 0 ++#define CONFIG_CINEPAK_ENCODER 0 ++#define CONFIG_CLJR_ENCODER 0 ++#define CONFIG_COMFORTNOISE_ENCODER 0 ++#define CONFIG_DNXHD_ENCODER 0 ++#define CONFIG_DPX_ENCODER 0 ++#define CONFIG_DVVIDEO_ENCODER 0 ++#define CONFIG_FFV1_ENCODER 0 ++#define CONFIG_FFVHUFF_ENCODER 0 ++#define CONFIG_FITS_ENCODER 0 ++#define CONFIG_FLASHSV_ENCODER 0 ++#define CONFIG_FLASHSV2_ENCODER 0 ++#define CONFIG_FLV_ENCODER 0 ++#define CONFIG_GIF_ENCODER 0 ++#define CONFIG_H261_ENCODER 0 ++#define CONFIG_H263_ENCODER 0 ++#define CONFIG_H263P_ENCODER 0 ++#define CONFIG_HAP_ENCODER 0 ++#define CONFIG_HUFFYUV_ENCODER 0 ++#define CONFIG_JPEG2000_ENCODER 0 ++#define CONFIG_JPEGLS_ENCODER 0 ++#define CONFIG_LJPEG_ENCODER 0 ++#define CONFIG_MAGICYUV_ENCODER 0 ++#define CONFIG_MJPEG_ENCODER 0 ++#define CONFIG_MPEG1VIDEO_ENCODER 0 ++#define CONFIG_MPEG2VIDEO_ENCODER 0 ++#define CONFIG_MPEG4_ENCODER 0 ++#define CONFIG_MSMPEG4V2_ENCODER 0 ++#define CONFIG_MSMPEG4V3_ENCODER 0 ++#define CONFIG_MSVIDEO1_ENCODER 0 ++#define CONFIG_PAM_ENCODER 0 ++#define CONFIG_PBM_ENCODER 0 ++#define CONFIG_PCX_ENCODER 0 ++#define CONFIG_PGM_ENCODER 0 ++#define CONFIG_PGMYUV_ENCODER 0 ++#define CONFIG_PNG_ENCODER 0 ++#define CONFIG_PPM_ENCODER 0 ++#define CONFIG_PRORES_ENCODER 0 ++#define CONFIG_PRORES_AW_ENCODER 0 ++#define CONFIG_PRORES_KS_ENCODER 0 ++#define CONFIG_QTRLE_ENCODER 0 ++#define CONFIG_R10K_ENCODER 0 ++#define CONFIG_R210_ENCODER 0 ++#define CONFIG_RAWVIDEO_ENCODER 0 ++#define CONFIG_ROQ_ENCODER 0 ++#define CONFIG_RV10_ENCODER 0 ++#define CONFIG_RV20_ENCODER 0 ++#define CONFIG_S302M_ENCODER 0 ++#define CONFIG_SGI_ENCODER 0 ++#define CONFIG_SNOW_ENCODER 0 ++#define CONFIG_SUNRAST_ENCODER 0 ++#define CONFIG_SVQ1_ENCODER 0 ++#define CONFIG_TARGA_ENCODER 0 ++#define CONFIG_TIFF_ENCODER 0 ++#define CONFIG_UTVIDEO_ENCODER 0 ++#define CONFIG_V210_ENCODER 0 ++#define CONFIG_V308_ENCODER 0 ++#define CONFIG_V408_ENCODER 0 ++#define CONFIG_V410_ENCODER 0 ++#define CONFIG_VC2_ENCODER 0 ++#define CONFIG_WRAPPED_AVFRAME_ENCODER 0 ++#define CONFIG_WMV1_ENCODER 0 ++#define CONFIG_WMV2_ENCODER 0 ++#define CONFIG_XBM_ENCODER 0 ++#define CONFIG_XFACE_ENCODER 0 ++#define CONFIG_XWD_ENCODER 0 ++#define CONFIG_Y41P_ENCODER 0 ++#define CONFIG_YUV4_ENCODER 0 ++#define CONFIG_ZLIB_ENCODER 0 ++#define CONFIG_ZMBV_ENCODER 0 ++#define CONFIG_AAC_ENCODER 0 ++#define CONFIG_AC3_ENCODER 0 ++#define CONFIG_AC3_FIXED_ENCODER 0 ++#define CONFIG_ALAC_ENCODER 0 ++#define CONFIG_APTX_ENCODER 0 ++#define CONFIG_APTX_HD_ENCODER 0 ++#define CONFIG_DCA_ENCODER 0 ++#define CONFIG_EAC3_ENCODER 0 ++#define CONFIG_FLAC_ENCODER 0 ++#define CONFIG_G723_1_ENCODER 0 ++#define CONFIG_MLP_ENCODER 0 ++#define CONFIG_MP2_ENCODER 0 ++#define CONFIG_MP2FIXED_ENCODER 0 ++#define CONFIG_NELLYMOSER_ENCODER 0 ++#define CONFIG_OPUS_ENCODER 0 ++#define CONFIG_RA_144_ENCODER 0 ++#define CONFIG_SBC_ENCODER 0 ++#define CONFIG_SONIC_ENCODER 0 ++#define CONFIG_SONIC_LS_ENCODER 0 ++#define CONFIG_TRUEHD_ENCODER 0 ++#define CONFIG_TTA_ENCODER 0 ++#define CONFIG_VORBIS_ENCODER 0 ++#define CONFIG_WAVPACK_ENCODER 0 ++#define CONFIG_WMAV1_ENCODER 0 ++#define CONFIG_WMAV2_ENCODER 0 ++#define CONFIG_PCM_ALAW_ENCODER 0 ++#define CONFIG_PCM_F32BE_ENCODER 0 ++#define CONFIG_PCM_F32LE_ENCODER 0 ++#define CONFIG_PCM_F64BE_ENCODER 0 ++#define CONFIG_PCM_F64LE_ENCODER 0 ++#define CONFIG_PCM_MULAW_ENCODER 0 ++#define CONFIG_PCM_S8_ENCODER 0 ++#define CONFIG_PCM_S8_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S16BE_ENCODER 0 ++#define CONFIG_PCM_S16BE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S16LE_ENCODER 0 ++#define CONFIG_PCM_S16LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S24BE_ENCODER 0 ++#define CONFIG_PCM_S24DAUD_ENCODER 0 ++#define CONFIG_PCM_S24LE_ENCODER 0 ++#define CONFIG_PCM_S24LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S32BE_ENCODER 0 ++#define CONFIG_PCM_S32LE_ENCODER 0 ++#define CONFIG_PCM_S32LE_PLANAR_ENCODER 0 ++#define CONFIG_PCM_S64BE_ENCODER 0 ++#define CONFIG_PCM_S64LE_ENCODER 0 ++#define CONFIG_PCM_U8_ENCODER 0 ++#define CONFIG_PCM_U16BE_ENCODER 0 ++#define CONFIG_PCM_U16LE_ENCODER 0 ++#define CONFIG_PCM_U24BE_ENCODER 0 ++#define CONFIG_PCM_U24LE_ENCODER 0 ++#define CONFIG_PCM_U32BE_ENCODER 0 ++#define CONFIG_PCM_U32LE_ENCODER 0 ++#define CONFIG_PCM_VIDC_ENCODER 0 ++#define CONFIG_ROQ_DPCM_ENCODER 0 ++#define CONFIG_ADPCM_ADX_ENCODER 0 ++#define CONFIG_ADPCM_G722_ENCODER 0 ++#define CONFIG_ADPCM_G726_ENCODER 0 ++#define CONFIG_ADPCM_G726LE_ENCODER 0 ++#define CONFIG_ADPCM_IMA_QT_ENCODER 0 ++#define CONFIG_ADPCM_IMA_WAV_ENCODER 0 ++#define CONFIG_ADPCM_MS_ENCODER 0 ++#define CONFIG_ADPCM_SWF_ENCODER 0 ++#define CONFIG_ADPCM_YAMAHA_ENCODER 0 ++#define CONFIG_SSA_ENCODER 0 ++#define CONFIG_ASS_ENCODER 0 ++#define CONFIG_DVBSUB_ENCODER 0 ++#define CONFIG_DVDSUB_ENCODER 0 ++#define CONFIG_MOVTEXT_ENCODER 0 ++#define CONFIG_SRT_ENCODER 0 ++#define CONFIG_SUBRIP_ENCODER 0 ++#define CONFIG_TEXT_ENCODER 0 ++#define CONFIG_WEBVTT_ENCODER 0 ++#define CONFIG_XSUB_ENCODER 0 ++#define CONFIG_AAC_AT_ENCODER 0 ++#define CONFIG_ALAC_AT_ENCODER 0 ++#define CONFIG_ILBC_AT_ENCODER 0 ++#define CONFIG_PCM_ALAW_AT_ENCODER 0 ++#define CONFIG_PCM_MULAW_AT_ENCODER 0 ++#define CONFIG_LIBAOM_AV1_ENCODER 0 ++#define CONFIG_LIBCODEC2_ENCODER 0 ++#define CONFIG_LIBFDK_AAC_ENCODER 0 ++#define CONFIG_LIBGSM_ENCODER 0 ++#define CONFIG_LIBGSM_MS_ENCODER 0 ++#define CONFIG_LIBILBC_ENCODER 0 ++#define CONFIG_LIBMP3LAME_ENCODER 0 ++#define CONFIG_LIBOPENCORE_AMRNB_ENCODER 0 ++#define CONFIG_LIBOPENJPEG_ENCODER 0 ++#define CONFIG_LIBOPUS_ENCODER 0 ++#define CONFIG_LIBSHINE_ENCODER 0 ++#define CONFIG_LIBSPEEX_ENCODER 0 ++#define CONFIG_LIBTHEORA_ENCODER 0 ++#define CONFIG_LIBTWOLAME_ENCODER 0 ++#define CONFIG_LIBVO_AMRWBENC_ENCODER 0 ++#define CONFIG_LIBVORBIS_ENCODER 0 ++#define CONFIG_LIBVPX_VP8_ENCODER 0 ++#define CONFIG_LIBVPX_VP9_ENCODER 0 ++#define CONFIG_LIBWAVPACK_ENCODER 0 ++#define CONFIG_LIBWEBP_ANIM_ENCODER 0 ++#define CONFIG_LIBWEBP_ENCODER 0 ++#define CONFIG_LIBX262_ENCODER 0 ++#define CONFIG_LIBX264_ENCODER 0 ++#define CONFIG_LIBX264RGB_ENCODER 0 ++#define CONFIG_LIBX265_ENCODER 0 ++#define CONFIG_LIBXAVS_ENCODER 0 ++#define CONFIG_LIBXAVS2_ENCODER 0 ++#define CONFIG_LIBXVID_ENCODER 0 ++#define CONFIG_H263_V4L2M2M_ENCODER 0 ++#define CONFIG_LIBOPENH264_ENCODER 0 ++#define CONFIG_H264_AMF_ENCODER 0 ++#define CONFIG_H264_NVENC_ENCODER 0 ++#define CONFIG_H264_OMX_ENCODER 0 ++#define CONFIG_H264_QSV_ENCODER 0 ++#define CONFIG_H264_V4L2M2M_ENCODER 0 ++#define CONFIG_H264_VAAPI_ENCODER 0 ++#define CONFIG_H264_VIDEOTOOLBOX_ENCODER 0 ++#define CONFIG_NVENC_ENCODER 0 ++#define CONFIG_NVENC_H264_ENCODER 0 ++#define CONFIG_NVENC_HEVC_ENCODER 0 ++#define CONFIG_HEVC_AMF_ENCODER 0 ++#define CONFIG_HEVC_NVENC_ENCODER 0 ++#define CONFIG_HEVC_QSV_ENCODER 0 ++#define CONFIG_HEVC_V4L2M2M_ENCODER 0 ++#define CONFIG_HEVC_VAAPI_ENCODER 0 ++#define CONFIG_HEVC_VIDEOTOOLBOX_ENCODER 0 ++#define CONFIG_LIBKVAZAAR_ENCODER 0 ++#define CONFIG_MJPEG_QSV_ENCODER 0 ++#define CONFIG_MJPEG_VAAPI_ENCODER 0 ++#define CONFIG_MPEG2_QSV_ENCODER 0 ++#define CONFIG_MPEG2_VAAPI_ENCODER 0 ++#define CONFIG_MPEG4_V4L2M2M_ENCODER 0 ++#define CONFIG_VP8_V4L2M2M_ENCODER 0 ++#define CONFIG_VP8_VAAPI_ENCODER 0 ++#define CONFIG_VP9_VAAPI_ENCODER 0 ++#define CONFIG_H263_VAAPI_HWACCEL 0 ++#define CONFIG_H263_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_H264_D3D11VA_HWACCEL 0 ++#define CONFIG_H264_D3D11VA2_HWACCEL 0 ++#define CONFIG_H264_DXVA2_HWACCEL 0 ++#define CONFIG_H264_NVDEC_HWACCEL 0 ++#define CONFIG_H264_VAAPI_HWACCEL 0 ++#define CONFIG_H264_VDPAU_HWACCEL 0 ++#define CONFIG_H264_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_HEVC_D3D11VA_HWACCEL 0 ++#define CONFIG_HEVC_D3D11VA2_HWACCEL 0 ++#define CONFIG_HEVC_DXVA2_HWACCEL 0 ++#define CONFIG_HEVC_NVDEC_HWACCEL 0 ++#define CONFIG_HEVC_VAAPI_HWACCEL 0 ++#define CONFIG_HEVC_VDPAU_HWACCEL 0 ++#define CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MJPEG_NVDEC_HWACCEL 0 ++#define CONFIG_MJPEG_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG1_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG1_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MPEG1_XVMC_HWACCEL 0 ++#define CONFIG_MPEG2_D3D11VA_HWACCEL 0 ++#define CONFIG_MPEG2_D3D11VA2_HWACCEL 0 ++#define CONFIG_MPEG2_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG2_DXVA2_HWACCEL 0 ++#define CONFIG_MPEG2_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG2_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_MPEG2_XVMC_HWACCEL 0 ++#define CONFIG_MPEG4_NVDEC_HWACCEL 0 ++#define CONFIG_MPEG4_VAAPI_HWACCEL 0 ++#define CONFIG_MPEG4_VDPAU_HWACCEL 0 ++#define CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL 0 ++#define CONFIG_VC1_D3D11VA_HWACCEL 0 ++#define CONFIG_VC1_D3D11VA2_HWACCEL 0 ++#define CONFIG_VC1_DXVA2_HWACCEL 0 ++#define CONFIG_VC1_NVDEC_HWACCEL 0 ++#define CONFIG_VC1_VAAPI_HWACCEL 0 ++#define CONFIG_VC1_VDPAU_HWACCEL 0 ++#define CONFIG_VP8_NVDEC_HWACCEL 0 ++#define CONFIG_VP8_VAAPI_HWACCEL 0 ++#define CONFIG_VP9_D3D11VA_HWACCEL 0 ++#define CONFIG_VP9_D3D11VA2_HWACCEL 0 ++#define CONFIG_VP9_DXVA2_HWACCEL 0 ++#define CONFIG_VP9_NVDEC_HWACCEL 0 ++#define CONFIG_VP9_VAAPI_HWACCEL 0 ++#define CONFIG_WMV3_D3D11VA_HWACCEL 0 ++#define CONFIG_WMV3_D3D11VA2_HWACCEL 0 ++#define CONFIG_WMV3_DXVA2_HWACCEL 0 ++#define CONFIG_WMV3_NVDEC_HWACCEL 0 ++#define CONFIG_WMV3_VAAPI_HWACCEL 0 ++#define CONFIG_WMV3_VDPAU_HWACCEL 0 ++#define CONFIG_AAC_PARSER 0 ++#define CONFIG_AAC_LATM_PARSER 0 ++#define CONFIG_AC3_PARSER 0 ++#define CONFIG_ADX_PARSER 0 ++#define CONFIG_AV1_PARSER 0 ++#define CONFIG_AVS2_PARSER 0 ++#define CONFIG_BMP_PARSER 0 ++#define CONFIG_CAVSVIDEO_PARSER 0 ++#define CONFIG_COOK_PARSER 0 ++#define CONFIG_DCA_PARSER 0 ++#define CONFIG_DIRAC_PARSER 0 ++#define CONFIG_DNXHD_PARSER 0 ++#define CONFIG_DPX_PARSER 0 ++#define CONFIG_DVAUDIO_PARSER 0 ++#define CONFIG_DVBSUB_PARSER 0 ++#define CONFIG_DVDSUB_PARSER 0 ++#define CONFIG_DVD_NAV_PARSER 0 ++#define CONFIG_FLAC_PARSER 1 ++#define CONFIG_G729_PARSER 0 ++#define CONFIG_GSM_PARSER 0 ++#define CONFIG_H261_PARSER 0 ++#define CONFIG_H263_PARSER 0 ++#define CONFIG_H264_PARSER 0 ++#define CONFIG_HEVC_PARSER 0 ++#define CONFIG_MJPEG_PARSER 0 ++#define CONFIG_MLP_PARSER 0 ++#define CONFIG_MPEG4VIDEO_PARSER 0 ++#define CONFIG_MPEGAUDIO_PARSER 1 ++#define CONFIG_MPEGVIDEO_PARSER 0 ++#define CONFIG_OPUS_PARSER 1 ++#define CONFIG_PNG_PARSER 0 ++#define CONFIG_PNM_PARSER 0 ++#define CONFIG_RV30_PARSER 0 ++#define CONFIG_RV40_PARSER 0 ++#define CONFIG_SBC_PARSER 0 ++#define CONFIG_SIPR_PARSER 0 ++#define CONFIG_TAK_PARSER 0 ++#define CONFIG_VC1_PARSER 0 ++#define CONFIG_VORBIS_PARSER 1 ++#define CONFIG_VP3_PARSER 1 ++#define CONFIG_VP8_PARSER 1 ++#define CONFIG_VP9_PARSER 0 ++#define CONFIG_XMA_PARSER 0 ++#define CONFIG_ALSA_INDEV 0 ++#define CONFIG_ANDROID_CAMERA_INDEV 0 ++#define CONFIG_AVFOUNDATION_INDEV 0 ++#define CONFIG_BKTR_INDEV 0 ++#define CONFIG_DECKLINK_INDEV 0 ++#define CONFIG_LIBNDI_NEWTEK_INDEV 0 ++#define CONFIG_DSHOW_INDEV 0 ++#define CONFIG_FBDEV_INDEV 0 ++#define CONFIG_GDIGRAB_INDEV 0 ++#define CONFIG_IEC61883_INDEV 0 ++#define CONFIG_JACK_INDEV 0 ++#define CONFIG_KMSGRAB_INDEV 0 ++#define CONFIG_LAVFI_INDEV 0 ++#define CONFIG_OPENAL_INDEV 0 ++#define CONFIG_OSS_INDEV 0 ++#define CONFIG_PULSE_INDEV 0 ++#define CONFIG_SNDIO_INDEV 0 ++#define CONFIG_V4L2_INDEV 0 ++#define CONFIG_VFWCAP_INDEV 0 ++#define CONFIG_XCBGRAB_INDEV 0 ++#define CONFIG_LIBCDIO_INDEV 0 ++#define CONFIG_LIBDC1394_INDEV 0 ++#define CONFIG_ALSA_OUTDEV 0 ++#define CONFIG_CACA_OUTDEV 0 ++#define CONFIG_DECKLINK_OUTDEV 0 ++#define CONFIG_LIBNDI_NEWTEK_OUTDEV 0 ++#define CONFIG_FBDEV_OUTDEV 0 ++#define CONFIG_OPENGL_OUTDEV 0 ++#define CONFIG_OSS_OUTDEV 0 ++#define CONFIG_PULSE_OUTDEV 0 ++#define CONFIG_SDL2_OUTDEV 0 ++#define CONFIG_SNDIO_OUTDEV 0 ++#define CONFIG_V4L2_OUTDEV 0 ++#define CONFIG_XV_OUTDEV 0 ++#define CONFIG_ABENCH_FILTER 0 ++#define CONFIG_ACOMPRESSOR_FILTER 0 ++#define CONFIG_ACONTRAST_FILTER 0 ++#define CONFIG_ACOPY_FILTER 0 ++#define CONFIG_ACUE_FILTER 0 ++#define CONFIG_ACROSSFADE_FILTER 0 ++#define CONFIG_ACROSSOVER_FILTER 0 ++#define CONFIG_ACRUSHER_FILTER 0 ++#define CONFIG_ADECLICK_FILTER 0 ++#define CONFIG_ADECLIP_FILTER 0 ++#define CONFIG_ADELAY_FILTER 0 ++#define CONFIG_ADERIVATIVE_FILTER 0 ++#define CONFIG_AECHO_FILTER 0 ++#define CONFIG_AEMPHASIS_FILTER 0 ++#define CONFIG_AEVAL_FILTER 0 ++#define CONFIG_AFADE_FILTER 0 ++#define CONFIG_AFFTDN_FILTER 0 ++#define CONFIG_AFFTFILT_FILTER 0 ++#define CONFIG_AFIR_FILTER 0 ++#define CONFIG_AFORMAT_FILTER 0 ++#define CONFIG_AGATE_FILTER 0 ++#define CONFIG_AIIR_FILTER 0 ++#define CONFIG_AINTEGRAL_FILTER 0 ++#define CONFIG_AINTERLEAVE_FILTER 0 ++#define CONFIG_ALIMITER_FILTER 0 ++#define CONFIG_ALLPASS_FILTER 0 ++#define CONFIG_ALOOP_FILTER 0 ++#define CONFIG_AMERGE_FILTER 0 ++#define CONFIG_AMETADATA_FILTER 0 ++#define CONFIG_AMIX_FILTER 0 ++#define CONFIG_AMULTIPLY_FILTER 0 ++#define CONFIG_ANEQUALIZER_FILTER 0 ++#define CONFIG_ANULL_FILTER 0 ++#define CONFIG_APAD_FILTER 0 ++#define CONFIG_APERMS_FILTER 0 ++#define CONFIG_APHASER_FILTER 0 ++#define CONFIG_APULSATOR_FILTER 0 ++#define CONFIG_AREALTIME_FILTER 0 ++#define CONFIG_ARESAMPLE_FILTER 0 ++#define CONFIG_AREVERSE_FILTER 0 ++#define CONFIG_ASELECT_FILTER 0 ++#define CONFIG_ASENDCMD_FILTER 0 ++#define CONFIG_ASETNSAMPLES_FILTER 0 ++#define CONFIG_ASETPTS_FILTER 0 ++#define CONFIG_ASETRATE_FILTER 0 ++#define CONFIG_ASETTB_FILTER 0 ++#define CONFIG_ASHOWINFO_FILTER 0 ++#define CONFIG_ASIDEDATA_FILTER 0 ++#define CONFIG_ASPLIT_FILTER 0 ++#define CONFIG_ASTATS_FILTER 0 ++#define CONFIG_ASTREAMSELECT_FILTER 0 ++#define CONFIG_ATEMPO_FILTER 0 ++#define CONFIG_ATRIM_FILTER 0 ++#define CONFIG_AZMQ_FILTER 0 ++#define CONFIG_BANDPASS_FILTER 0 ++#define CONFIG_BANDREJECT_FILTER 0 ++#define CONFIG_BASS_FILTER 0 ++#define CONFIG_BIQUAD_FILTER 0 ++#define CONFIG_BS2B_FILTER 0 ++#define CONFIG_CHANNELMAP_FILTER 0 ++#define CONFIG_CHANNELSPLIT_FILTER 0 ++#define CONFIG_CHORUS_FILTER 0 ++#define CONFIG_COMPAND_FILTER 0 ++#define CONFIG_COMPENSATIONDELAY_FILTER 0 ++#define CONFIG_CROSSFEED_FILTER 0 ++#define CONFIG_CRYSTALIZER_FILTER 0 ++#define CONFIG_DCSHIFT_FILTER 0 ++#define CONFIG_DRMETER_FILTER 0 ++#define CONFIG_DYNAUDNORM_FILTER 0 ++#define CONFIG_EARWAX_FILTER 0 ++#define CONFIG_EBUR128_FILTER 0 ++#define CONFIG_EQUALIZER_FILTER 0 ++#define CONFIG_EXTRASTEREO_FILTER 0 ++#define CONFIG_FIREQUALIZER_FILTER 0 ++#define CONFIG_FLANGER_FILTER 0 ++#define CONFIG_HAAS_FILTER 0 ++#define CONFIG_HDCD_FILTER 0 ++#define CONFIG_HEADPHONE_FILTER 0 ++#define CONFIG_HIGHPASS_FILTER 0 ++#define CONFIG_HIGHSHELF_FILTER 0 ++#define CONFIG_JOIN_FILTER 0 ++#define CONFIG_LADSPA_FILTER 0 ++#define CONFIG_LOUDNORM_FILTER 0 ++#define CONFIG_LOWPASS_FILTER 0 ++#define CONFIG_LOWSHELF_FILTER 0 ++#define CONFIG_LV2_FILTER 0 ++#define CONFIG_MCOMPAND_FILTER 0 ++#define CONFIG_PAN_FILTER 0 ++#define CONFIG_REPLAYGAIN_FILTER 0 ++#define CONFIG_RESAMPLE_FILTER 0 ++#define CONFIG_RUBBERBAND_FILTER 0 ++#define CONFIG_SIDECHAINCOMPRESS_FILTER 0 ++#define CONFIG_SIDECHAINGATE_FILTER 0 ++#define CONFIG_SILENCEDETECT_FILTER 0 ++#define CONFIG_SILENCEREMOVE_FILTER 0 ++#define CONFIG_SOFALIZER_FILTER 0 ++#define CONFIG_STEREOTOOLS_FILTER 0 ++#define CONFIG_STEREOWIDEN_FILTER 0 ++#define CONFIG_SUPEREQUALIZER_FILTER 0 ++#define CONFIG_SURROUND_FILTER 0 ++#define CONFIG_TREBLE_FILTER 0 ++#define CONFIG_TREMOLO_FILTER 0 ++#define CONFIG_VIBRATO_FILTER 0 ++#define CONFIG_VOLUME_FILTER 0 ++#define CONFIG_VOLUMEDETECT_FILTER 0 ++#define CONFIG_AEVALSRC_FILTER 0 ++#define CONFIG_ANOISESRC_FILTER 0 ++#define CONFIG_ANULLSRC_FILTER 0 ++#define CONFIG_FLITE_FILTER 0 ++#define CONFIG_HILBERT_FILTER 0 ++#define CONFIG_SINC_FILTER 0 ++#define CONFIG_SINE_FILTER 0 ++#define CONFIG_ANULLSINK_FILTER 0 ++#define CONFIG_ALPHAEXTRACT_FILTER 0 ++#define CONFIG_ALPHAMERGE_FILTER 0 ++#define CONFIG_AMPLIFY_FILTER 0 ++#define CONFIG_ASS_FILTER 0 ++#define CONFIG_ATADENOISE_FILTER 0 ++#define CONFIG_AVGBLUR_FILTER 0 ++#define CONFIG_AVGBLUR_OPENCL_FILTER 0 ++#define CONFIG_BBOX_FILTER 0 ++#define CONFIG_BENCH_FILTER 0 ++#define CONFIG_BITPLANENOISE_FILTER 0 ++#define CONFIG_BLACKDETECT_FILTER 0 ++#define CONFIG_BLACKFRAME_FILTER 0 ++#define CONFIG_BLEND_FILTER 0 ++#define CONFIG_BM3D_FILTER 0 ++#define CONFIG_BOXBLUR_FILTER 0 ++#define CONFIG_BOXBLUR_OPENCL_FILTER 0 ++#define CONFIG_BWDIF_FILTER 0 ++#define CONFIG_CHROMAHOLD_FILTER 0 ++#define CONFIG_CHROMAKEY_FILTER 0 ++#define CONFIG_CHROMASHIFT_FILTER 0 ++#define CONFIG_CIESCOPE_FILTER 0 ++#define CONFIG_CODECVIEW_FILTER 0 ++#define CONFIG_COLORBALANCE_FILTER 0 ++#define CONFIG_COLORCHANNELMIXER_FILTER 0 ++#define CONFIG_COLORKEY_FILTER 0 ++#define CONFIG_COLORLEVELS_FILTER 0 ++#define CONFIG_COLORMATRIX_FILTER 0 ++#define CONFIG_COLORSPACE_FILTER 0 ++#define CONFIG_CONVOLUTION_FILTER 0 ++#define CONFIG_CONVOLUTION_OPENCL_FILTER 0 ++#define CONFIG_CONVOLVE_FILTER 0 ++#define CONFIG_COPY_FILTER 0 ++#define CONFIG_COREIMAGE_FILTER 0 ++#define CONFIG_COVER_RECT_FILTER 0 ++#define CONFIG_CROP_FILTER 0 ++#define CONFIG_CROPDETECT_FILTER 0 ++#define CONFIG_CUE_FILTER 0 ++#define CONFIG_CURVES_FILTER 0 ++#define CONFIG_DATASCOPE_FILTER 0 ++#define CONFIG_DCTDNOIZ_FILTER 0 ++#define CONFIG_DEBAND_FILTER 0 ++#define CONFIG_DEBLOCK_FILTER 0 ++#define CONFIG_DECIMATE_FILTER 0 ++#define CONFIG_DECONVOLVE_FILTER 0 ++#define CONFIG_DEDOT_FILTER 0 ++#define CONFIG_DEFLATE_FILTER 0 ++#define CONFIG_DEFLICKER_FILTER 0 ++#define CONFIG_DEINTERLACE_QSV_FILTER 0 ++#define CONFIG_DEINTERLACE_VAAPI_FILTER 0 ++#define CONFIG_DEJUDDER_FILTER 0 ++#define CONFIG_DELOGO_FILTER 0 ++#define CONFIG_DENOISE_VAAPI_FILTER 0 ++#define CONFIG_DESHAKE_FILTER 0 ++#define CONFIG_DESPILL_FILTER 0 ++#define CONFIG_DETELECINE_FILTER 0 ++#define CONFIG_DILATION_FILTER 0 ++#define CONFIG_DILATION_OPENCL_FILTER 0 ++#define CONFIG_DISPLACE_FILTER 0 ++#define CONFIG_DOUBLEWEAVE_FILTER 0 ++#define CONFIG_DRAWBOX_FILTER 0 ++#define CONFIG_DRAWGRAPH_FILTER 0 ++#define CONFIG_DRAWGRID_FILTER 0 ++#define CONFIG_DRAWTEXT_FILTER 0 ++#define CONFIG_EDGEDETECT_FILTER 0 ++#define CONFIG_ELBG_FILTER 0 ++#define CONFIG_ENTROPY_FILTER 0 ++#define CONFIG_EQ_FILTER 0 ++#define CONFIG_EROSION_FILTER 0 ++#define CONFIG_EROSION_OPENCL_FILTER 0 ++#define CONFIG_EXTRACTPLANES_FILTER 0 ++#define CONFIG_FADE_FILTER 0 ++#define CONFIG_FFTDNOIZ_FILTER 0 ++#define CONFIG_FFTFILT_FILTER 0 ++#define CONFIG_FIELD_FILTER 0 ++#define CONFIG_FIELDHINT_FILTER 0 ++#define CONFIG_FIELDMATCH_FILTER 0 ++#define CONFIG_FIELDORDER_FILTER 0 ++#define CONFIG_FILLBORDERS_FILTER 0 ++#define CONFIG_FIND_RECT_FILTER 0 ++#define CONFIG_FLOODFILL_FILTER 0 ++#define CONFIG_FORMAT_FILTER 0 ++#define CONFIG_FPS_FILTER 0 ++#define CONFIG_FRAMEPACK_FILTER 0 ++#define CONFIG_FRAMERATE_FILTER 0 ++#define CONFIG_FRAMESTEP_FILTER 0 ++#define CONFIG_FREEZEDETECT_FILTER 0 ++#define CONFIG_FREI0R_FILTER 0 ++#define CONFIG_FSPP_FILTER 0 ++#define CONFIG_GBLUR_FILTER 0 ++#define CONFIG_GEQ_FILTER 0 ++#define CONFIG_GRADFUN_FILTER 0 ++#define CONFIG_GRAPHMONITOR_FILTER 0 ++#define CONFIG_GREYEDGE_FILTER 0 ++#define CONFIG_HALDCLUT_FILTER 0 ++#define CONFIG_HFLIP_FILTER 0 ++#define CONFIG_HISTEQ_FILTER 0 ++#define CONFIG_HISTOGRAM_FILTER 0 ++#define CONFIG_HQDN3D_FILTER 0 ++#define CONFIG_HQX_FILTER 0 ++#define CONFIG_HSTACK_FILTER 0 ++#define CONFIG_HUE_FILTER 0 ++#define CONFIG_HWDOWNLOAD_FILTER 0 ++#define CONFIG_HWMAP_FILTER 0 ++#define CONFIG_HWUPLOAD_FILTER 0 ++#define CONFIG_HWUPLOAD_CUDA_FILTER 0 ++#define CONFIG_HYSTERESIS_FILTER 0 ++#define CONFIG_IDET_FILTER 0 ++#define CONFIG_IL_FILTER 0 ++#define CONFIG_INFLATE_FILTER 0 ++#define CONFIG_INTERLACE_FILTER 0 ++#define CONFIG_INTERLEAVE_FILTER 0 ++#define CONFIG_KERNDEINT_FILTER 0 ++#define CONFIG_LENSCORRECTION_FILTER 0 ++#define CONFIG_LENSFUN_FILTER 0 ++#define CONFIG_LIBVMAF_FILTER 0 ++#define CONFIG_LIMITER_FILTER 0 ++#define CONFIG_LOOP_FILTER 0 ++#define CONFIG_LUMAKEY_FILTER 0 ++#define CONFIG_LUT_FILTER 0 ++#define CONFIG_LUT1D_FILTER 0 ++#define CONFIG_LUT2_FILTER 0 ++#define CONFIG_LUT3D_FILTER 0 ++#define CONFIG_LUTRGB_FILTER 0 ++#define CONFIG_LUTYUV_FILTER 0 ++#define CONFIG_MASKEDCLAMP_FILTER 0 ++#define CONFIG_MASKEDMERGE_FILTER 0 ++#define CONFIG_MCDEINT_FILTER 0 ++#define CONFIG_MERGEPLANES_FILTER 0 ++#define CONFIG_MESTIMATE_FILTER 0 ++#define CONFIG_METADATA_FILTER 0 ++#define CONFIG_MIDEQUALIZER_FILTER 0 ++#define CONFIG_MINTERPOLATE_FILTER 0 ++#define CONFIG_MIX_FILTER 0 ++#define CONFIG_MPDECIMATE_FILTER 0 ++#define CONFIG_NEGATE_FILTER 0 ++#define CONFIG_NLMEANS_FILTER 0 ++#define CONFIG_NNEDI_FILTER 0 ++#define CONFIG_NOFORMAT_FILTER 0 ++#define CONFIG_NOISE_FILTER 0 ++#define CONFIG_NORMALIZE_FILTER 0 ++#define CONFIG_NULL_FILTER 0 ++#define CONFIG_OCR_FILTER 0 ++#define CONFIG_OCV_FILTER 0 ++#define CONFIG_OSCILLOSCOPE_FILTER 0 ++#define CONFIG_OVERLAY_FILTER 0 ++#define CONFIG_OVERLAY_OPENCL_FILTER 0 ++#define CONFIG_OVERLAY_QSV_FILTER 0 ++#define CONFIG_OWDENOISE_FILTER 0 ++#define CONFIG_PAD_FILTER 0 ++#define CONFIG_PALETTEGEN_FILTER 0 ++#define CONFIG_PALETTEUSE_FILTER 0 ++#define CONFIG_PERMS_FILTER 0 ++#define CONFIG_PERSPECTIVE_FILTER 0 ++#define CONFIG_PHASE_FILTER 0 ++#define CONFIG_PIXDESCTEST_FILTER 0 ++#define CONFIG_PIXSCOPE_FILTER 0 ++#define CONFIG_PP_FILTER 0 ++#define CONFIG_PP7_FILTER 0 ++#define CONFIG_PREMULTIPLY_FILTER 0 ++#define CONFIG_PREWITT_FILTER 0 ++#define CONFIG_PREWITT_OPENCL_FILTER 0 ++#define CONFIG_PROCAMP_VAAPI_FILTER 0 ++#define CONFIG_PROGRAM_OPENCL_FILTER 0 ++#define CONFIG_PSEUDOCOLOR_FILTER 0 ++#define CONFIG_PSNR_FILTER 0 ++#define CONFIG_PULLUP_FILTER 0 ++#define CONFIG_QP_FILTER 0 ++#define CONFIG_RANDOM_FILTER 0 ++#define CONFIG_READEIA608_FILTER 0 ++#define CONFIG_READVITC_FILTER 0 ++#define CONFIG_REALTIME_FILTER 0 ++#define CONFIG_REMAP_FILTER 0 ++#define CONFIG_REMOVEGRAIN_FILTER 0 ++#define CONFIG_REMOVELOGO_FILTER 0 ++#define CONFIG_REPEATFIELDS_FILTER 0 ++#define CONFIG_REVERSE_FILTER 0 ++#define CONFIG_RGBASHIFT_FILTER 0 ++#define CONFIG_ROBERTS_FILTER 0 ++#define CONFIG_ROBERTS_OPENCL_FILTER 0 ++#define CONFIG_ROTATE_FILTER 0 ++#define CONFIG_SAB_FILTER 0 ++#define CONFIG_SCALE_FILTER 0 ++#define CONFIG_SCALE_CUDA_FILTER 0 ++#define CONFIG_SCALE_NPP_FILTER 0 ++#define CONFIG_SCALE_QSV_FILTER 0 ++#define CONFIG_SCALE_VAAPI_FILTER 0 ++#define CONFIG_SCALE2REF_FILTER 0 ++#define CONFIG_SELECT_FILTER 0 ++#define CONFIG_SELECTIVECOLOR_FILTER 0 ++#define CONFIG_SENDCMD_FILTER 0 ++#define CONFIG_SEPARATEFIELDS_FILTER 0 ++#define CONFIG_SETDAR_FILTER 0 ++#define CONFIG_SETFIELD_FILTER 0 ++#define CONFIG_SETPARAMS_FILTER 0 ++#define CONFIG_SETPTS_FILTER 0 ++#define CONFIG_SETRANGE_FILTER 0 ++#define CONFIG_SETSAR_FILTER 0 ++#define CONFIG_SETTB_FILTER 0 ++#define CONFIG_SHARPNESS_VAAPI_FILTER 0 ++#define CONFIG_SHOWINFO_FILTER 0 ++#define CONFIG_SHOWPALETTE_FILTER 0 ++#define CONFIG_SHUFFLEFRAMES_FILTER 0 ++#define CONFIG_SHUFFLEPLANES_FILTER 0 ++#define CONFIG_SIDEDATA_FILTER 0 ++#define CONFIG_SIGNALSTATS_FILTER 0 ++#define CONFIG_SIGNATURE_FILTER 0 ++#define CONFIG_SMARTBLUR_FILTER 0 ++#define CONFIG_SOBEL_FILTER 0 ++#define CONFIG_SOBEL_OPENCL_FILTER 0 ++#define CONFIG_SPLIT_FILTER 0 ++#define CONFIG_SPP_FILTER 0 ++#define CONFIG_SR_FILTER 0 ++#define CONFIG_SSIM_FILTER 0 ++#define CONFIG_STEREO3D_FILTER 0 ++#define CONFIG_STREAMSELECT_FILTER 0 ++#define CONFIG_SUBTITLES_FILTER 0 ++#define CONFIG_SUPER2XSAI_FILTER 0 ++#define CONFIG_SWAPRECT_FILTER 0 ++#define CONFIG_SWAPUV_FILTER 0 ++#define CONFIG_TBLEND_FILTER 0 ++#define CONFIG_TELECINE_FILTER 0 ++#define CONFIG_THRESHOLD_FILTER 0 ++#define CONFIG_THUMBNAIL_FILTER 0 ++#define CONFIG_THUMBNAIL_CUDA_FILTER 0 ++#define CONFIG_TILE_FILTER 0 ++#define CONFIG_TINTERLACE_FILTER 0 ++#define CONFIG_TLUT2_FILTER 0 ++#define CONFIG_TMIX_FILTER 0 ++#define CONFIG_TONEMAP_FILTER 0 ++#define CONFIG_TONEMAP_OPENCL_FILTER 0 ++#define CONFIG_TPAD_FILTER 0 ++#define CONFIG_TRANSPOSE_FILTER 0 ++#define CONFIG_TRANSPOSE_NPP_FILTER 0 ++#define CONFIG_TRIM_FILTER 0 ++#define CONFIG_UNPREMULTIPLY_FILTER 0 ++#define CONFIG_UNSHARP_FILTER 0 ++#define CONFIG_UNSHARP_OPENCL_FILTER 0 ++#define CONFIG_USPP_FILTER 0 ++#define CONFIG_VAGUEDENOISER_FILTER 0 ++#define CONFIG_VECTORSCOPE_FILTER 0 ++#define CONFIG_VFLIP_FILTER 0 ++#define CONFIG_VFRDET_FILTER 0 ++#define CONFIG_VIBRANCE_FILTER 0 ++#define CONFIG_VIDSTABDETECT_FILTER 0 ++#define CONFIG_VIDSTABTRANSFORM_FILTER 0 ++#define CONFIG_VIGNETTE_FILTER 0 ++#define CONFIG_VMAFMOTION_FILTER 0 ++#define CONFIG_VPP_QSV_FILTER 0 ++#define CONFIG_VSTACK_FILTER 0 ++#define CONFIG_W3FDIF_FILTER 0 ++#define CONFIG_WAVEFORM_FILTER 0 ++#define CONFIG_WEAVE_FILTER 0 ++#define CONFIG_XBR_FILTER 0 ++#define CONFIG_XSTACK_FILTER 0 ++#define CONFIG_YADIF_FILTER 0 ++#define CONFIG_YADIF_CUDA_FILTER 0 ++#define CONFIG_ZMQ_FILTER 0 ++#define CONFIG_ZOOMPAN_FILTER 0 ++#define CONFIG_ZSCALE_FILTER 0 ++#define CONFIG_ALLRGB_FILTER 0 ++#define CONFIG_ALLYUV_FILTER 0 ++#define CONFIG_CELLAUTO_FILTER 0 ++#define CONFIG_COLOR_FILTER 0 ++#define CONFIG_COREIMAGESRC_FILTER 0 ++#define CONFIG_FREI0R_SRC_FILTER 0 ++#define CONFIG_HALDCLUTSRC_FILTER 0 ++#define CONFIG_LIFE_FILTER 0 ++#define CONFIG_MANDELBROT_FILTER 0 ++#define CONFIG_MPTESTSRC_FILTER 0 ++#define CONFIG_NULLSRC_FILTER 0 ++#define CONFIG_OPENCLSRC_FILTER 0 ++#define CONFIG_PAL75BARS_FILTER 0 ++#define CONFIG_PAL100BARS_FILTER 0 ++#define CONFIG_RGBTESTSRC_FILTER 0 ++#define CONFIG_SMPTEBARS_FILTER 0 ++#define CONFIG_SMPTEHDBARS_FILTER 0 ++#define CONFIG_TESTSRC_FILTER 0 ++#define CONFIG_TESTSRC2_FILTER 0 ++#define CONFIG_YUVTESTSRC_FILTER 0 ++#define CONFIG_NULLSINK_FILTER 0 ++#define CONFIG_ABITSCOPE_FILTER 0 ++#define CONFIG_ADRAWGRAPH_FILTER 0 ++#define CONFIG_AGRAPHMONITOR_FILTER 0 ++#define CONFIG_AHISTOGRAM_FILTER 0 ++#define CONFIG_APHASEMETER_FILTER 0 ++#define CONFIG_AVECTORSCOPE_FILTER 0 ++#define CONFIG_CONCAT_FILTER 0 ++#define CONFIG_SHOWCQT_FILTER 0 ++#define CONFIG_SHOWFREQS_FILTER 0 ++#define CONFIG_SHOWSPECTRUM_FILTER 0 ++#define CONFIG_SHOWSPECTRUMPIC_FILTER 0 ++#define CONFIG_SHOWVOLUME_FILTER 0 ++#define CONFIG_SHOWWAVES_FILTER 0 ++#define CONFIG_SHOWWAVESPIC_FILTER 0 ++#define CONFIG_SPECTRUMSYNTH_FILTER 0 ++#define CONFIG_AMOVIE_FILTER 0 ++#define CONFIG_MOVIE_FILTER 0 ++#define CONFIG_AFIFO_FILTER 0 ++#define CONFIG_FIFO_FILTER 0 ++#define CONFIG_AA_DEMUXER 0 ++#define CONFIG_AAC_DEMUXER 0 ++#define CONFIG_AC3_DEMUXER 0 ++#define CONFIG_ACM_DEMUXER 0 ++#define CONFIG_ACT_DEMUXER 0 ++#define CONFIG_ADF_DEMUXER 0 ++#define CONFIG_ADP_DEMUXER 0 ++#define CONFIG_ADS_DEMUXER 0 ++#define CONFIG_ADX_DEMUXER 0 ++#define CONFIG_AEA_DEMUXER 0 ++#define CONFIG_AFC_DEMUXER 0 ++#define CONFIG_AIFF_DEMUXER 0 ++#define CONFIG_AIX_DEMUXER 0 ++#define CONFIG_AMR_DEMUXER 0 ++#define CONFIG_AMRNB_DEMUXER 0 ++#define CONFIG_AMRWB_DEMUXER 0 ++#define CONFIG_ANM_DEMUXER 0 ++#define CONFIG_APC_DEMUXER 0 ++#define CONFIG_APE_DEMUXER 0 ++#define CONFIG_APNG_DEMUXER 0 ++#define CONFIG_APTX_DEMUXER 0 ++#define CONFIG_APTX_HD_DEMUXER 0 ++#define CONFIG_AQTITLE_DEMUXER 0 ++#define CONFIG_ASF_DEMUXER 0 ++#define CONFIG_ASF_O_DEMUXER 0 ++#define CONFIG_ASS_DEMUXER 0 ++#define CONFIG_AST_DEMUXER 0 ++#define CONFIG_AU_DEMUXER 0 ++#define CONFIG_AVI_DEMUXER 0 ++#define CONFIG_AVISYNTH_DEMUXER 0 ++#define CONFIG_AVR_DEMUXER 0 ++#define CONFIG_AVS_DEMUXER 0 ++#define CONFIG_AVS2_DEMUXER 0 ++#define CONFIG_BETHSOFTVID_DEMUXER 0 ++#define CONFIG_BFI_DEMUXER 0 ++#define CONFIG_BINTEXT_DEMUXER 0 ++#define CONFIG_BINK_DEMUXER 0 ++#define CONFIG_BIT_DEMUXER 0 ++#define CONFIG_BMV_DEMUXER 0 ++#define CONFIG_BFSTM_DEMUXER 0 ++#define CONFIG_BRSTM_DEMUXER 0 ++#define CONFIG_BOA_DEMUXER 0 ++#define CONFIG_C93_DEMUXER 0 ++#define CONFIG_CAF_DEMUXER 0 ++#define CONFIG_CAVSVIDEO_DEMUXER 0 ++#define CONFIG_CDG_DEMUXER 0 ++#define CONFIG_CDXL_DEMUXER 0 ++#define CONFIG_CINE_DEMUXER 0 ++#define CONFIG_CODEC2_DEMUXER 0 ++#define CONFIG_CODEC2RAW_DEMUXER 0 ++#define CONFIG_CONCAT_DEMUXER 0 ++#define CONFIG_DASH_DEMUXER 0 ++#define CONFIG_DATA_DEMUXER 0 ++#define CONFIG_DAUD_DEMUXER 0 ++#define CONFIG_DCSTR_DEMUXER 0 ++#define CONFIG_DFA_DEMUXER 0 ++#define CONFIG_DHAV_DEMUXER 0 ++#define CONFIG_DIRAC_DEMUXER 0 ++#define CONFIG_DNXHD_DEMUXER 0 ++#define CONFIG_DSF_DEMUXER 0 ++#define CONFIG_DSICIN_DEMUXER 0 ++#define CONFIG_DSS_DEMUXER 0 ++#define CONFIG_DTS_DEMUXER 0 ++#define CONFIG_DTSHD_DEMUXER 0 ++#define CONFIG_DV_DEMUXER 0 ++#define CONFIG_DVBSUB_DEMUXER 0 ++#define CONFIG_DVBTXT_DEMUXER 0 ++#define CONFIG_DXA_DEMUXER 0 ++#define CONFIG_EA_DEMUXER 0 ++#define CONFIG_EA_CDATA_DEMUXER 0 ++#define CONFIG_EAC3_DEMUXER 0 ++#define CONFIG_EPAF_DEMUXER 0 ++#define CONFIG_FFMETADATA_DEMUXER 0 ++#define CONFIG_FILMSTRIP_DEMUXER 0 ++#define CONFIG_FITS_DEMUXER 0 ++#define CONFIG_FLAC_DEMUXER 1 ++#define CONFIG_FLIC_DEMUXER 0 ++#define CONFIG_FLV_DEMUXER 0 ++#define CONFIG_LIVE_FLV_DEMUXER 0 ++#define CONFIG_FOURXM_DEMUXER 0 ++#define CONFIG_FRM_DEMUXER 0 ++#define CONFIG_FSB_DEMUXER 0 ++#define CONFIG_G722_DEMUXER 0 ++#define CONFIG_G723_1_DEMUXER 0 ++#define CONFIG_G726_DEMUXER 0 ++#define CONFIG_G726LE_DEMUXER 0 ++#define CONFIG_G729_DEMUXER 0 ++#define CONFIG_GDV_DEMUXER 0 ++#define CONFIG_GENH_DEMUXER 0 ++#define CONFIG_GIF_DEMUXER 0 ++#define CONFIG_GSM_DEMUXER 0 ++#define CONFIG_GXF_DEMUXER 0 ++#define CONFIG_H261_DEMUXER 0 ++#define CONFIG_H263_DEMUXER 0 ++#define CONFIG_H264_DEMUXER 0 ++#define CONFIG_HEVC_DEMUXER 0 ++#define CONFIG_HLS_DEMUXER 0 ++#define CONFIG_HNM_DEMUXER 0 ++#define CONFIG_ICO_DEMUXER 0 ++#define CONFIG_IDCIN_DEMUXER 0 ++#define CONFIG_IDF_DEMUXER 0 ++#define CONFIG_IFF_DEMUXER 0 ++#define CONFIG_ILBC_DEMUXER 0 ++#define CONFIG_IMAGE2_DEMUXER 0 ++#define CONFIG_IMAGE2PIPE_DEMUXER 0 ++#define CONFIG_IMAGE2_ALIAS_PIX_DEMUXER 0 ++#define CONFIG_IMAGE2_BRENDER_PIX_DEMUXER 0 ++#define CONFIG_INGENIENT_DEMUXER 0 ++#define CONFIG_IPMOVIE_DEMUXER 0 ++#define CONFIG_IRCAM_DEMUXER 0 ++#define CONFIG_ISS_DEMUXER 0 ++#define CONFIG_IV8_DEMUXER 0 ++#define CONFIG_IVF_DEMUXER 0 ++#define CONFIG_IVR_DEMUXER 0 ++#define CONFIG_JACOSUB_DEMUXER 0 ++#define CONFIG_JV_DEMUXER 0 ++#define CONFIG_LMLM4_DEMUXER 0 ++#define CONFIG_LOAS_DEMUXER 0 ++#define CONFIG_LRC_DEMUXER 0 ++#define CONFIG_LVF_DEMUXER 0 ++#define CONFIG_LXF_DEMUXER 0 ++#define CONFIG_M4V_DEMUXER 0 ++#define CONFIG_MATROSKA_DEMUXER 1 ++#define CONFIG_MGSTS_DEMUXER 0 ++#define CONFIG_MICRODVD_DEMUXER 0 ++#define CONFIG_MJPEG_DEMUXER 0 ++#define CONFIG_MJPEG_2000_DEMUXER 0 ++#define CONFIG_MLP_DEMUXER 0 ++#define CONFIG_MLV_DEMUXER 0 ++#define CONFIG_MM_DEMUXER 0 ++#define CONFIG_MMF_DEMUXER 0 ++#define CONFIG_MOV_DEMUXER 1 ++#define CONFIG_MP3_DEMUXER 1 ++#define CONFIG_MPC_DEMUXER 0 ++#define CONFIG_MPC8_DEMUXER 0 ++#define CONFIG_MPEGPS_DEMUXER 0 ++#define CONFIG_MPEGTS_DEMUXER 0 ++#define CONFIG_MPEGTSRAW_DEMUXER 0 ++#define CONFIG_MPEGVIDEO_DEMUXER 0 ++#define CONFIG_MPJPEG_DEMUXER 0 ++#define CONFIG_MPL2_DEMUXER 0 ++#define CONFIG_MPSUB_DEMUXER 0 ++#define CONFIG_MSF_DEMUXER 0 ++#define CONFIG_MSNWC_TCP_DEMUXER 0 ++#define CONFIG_MTAF_DEMUXER 0 ++#define CONFIG_MTV_DEMUXER 0 ++#define CONFIG_MUSX_DEMUXER 0 ++#define CONFIG_MV_DEMUXER 0 ++#define CONFIG_MVI_DEMUXER 0 ++#define CONFIG_MXF_DEMUXER 0 ++#define CONFIG_MXG_DEMUXER 0 ++#define CONFIG_NC_DEMUXER 0 ++#define CONFIG_NISTSPHERE_DEMUXER 0 ++#define CONFIG_NSP_DEMUXER 0 ++#define CONFIG_NSV_DEMUXER 0 ++#define CONFIG_NUT_DEMUXER 0 ++#define CONFIG_NUV_DEMUXER 0 ++#define CONFIG_OGG_DEMUXER 1 ++#define CONFIG_OMA_DEMUXER 0 ++#define CONFIG_PAF_DEMUXER 0 ++#define CONFIG_PCM_ALAW_DEMUXER 0 ++#define CONFIG_PCM_MULAW_DEMUXER 0 ++#define CONFIG_PCM_VIDC_DEMUXER 0 ++#define CONFIG_PCM_F64BE_DEMUXER 0 ++#define CONFIG_PCM_F64LE_DEMUXER 0 ++#define CONFIG_PCM_F32BE_DEMUXER 0 ++#define CONFIG_PCM_F32LE_DEMUXER 0 ++#define CONFIG_PCM_S32BE_DEMUXER 0 ++#define CONFIG_PCM_S32LE_DEMUXER 0 ++#define CONFIG_PCM_S24BE_DEMUXER 0 ++#define CONFIG_PCM_S24LE_DEMUXER 0 ++#define CONFIG_PCM_S16BE_DEMUXER 0 ++#define CONFIG_PCM_S16LE_DEMUXER 0 ++#define CONFIG_PCM_S8_DEMUXER 0 ++#define CONFIG_PCM_U32BE_DEMUXER 0 ++#define CONFIG_PCM_U32LE_DEMUXER 0 ++#define CONFIG_PCM_U24BE_DEMUXER 0 ++#define CONFIG_PCM_U24LE_DEMUXER 0 ++#define CONFIG_PCM_U16BE_DEMUXER 0 ++#define CONFIG_PCM_U16LE_DEMUXER 0 ++#define CONFIG_PCM_U8_DEMUXER 0 ++#define CONFIG_PJS_DEMUXER 0 ++#define CONFIG_PMP_DEMUXER 0 ++#define CONFIG_PVA_DEMUXER 0 ++#define CONFIG_PVF_DEMUXER 0 ++#define CONFIG_QCP_DEMUXER 0 ++#define CONFIG_R3D_DEMUXER 0 ++#define CONFIG_RAWVIDEO_DEMUXER 0 ++#define CONFIG_REALTEXT_DEMUXER 0 ++#define CONFIG_REDSPARK_DEMUXER 0 ++#define CONFIG_RL2_DEMUXER 0 ++#define CONFIG_RM_DEMUXER 0 ++#define CONFIG_ROQ_DEMUXER 0 ++#define CONFIG_RPL_DEMUXER 0 ++#define CONFIG_RSD_DEMUXER 0 ++#define CONFIG_RSO_DEMUXER 0 ++#define CONFIG_RTP_DEMUXER 0 ++#define CONFIG_RTSP_DEMUXER 0 ++#define CONFIG_S337M_DEMUXER 0 ++#define CONFIG_SAMI_DEMUXER 0 ++#define CONFIG_SAP_DEMUXER 0 ++#define CONFIG_SBC_DEMUXER 0 ++#define CONFIG_SBG_DEMUXER 0 ++#define CONFIG_SCC_DEMUXER 0 ++#define CONFIG_SDP_DEMUXER 0 ++#define CONFIG_SDR2_DEMUXER 0 ++#define CONFIG_SDS_DEMUXER 0 ++#define CONFIG_SDX_DEMUXER 0 ++#define CONFIG_SEGAFILM_DEMUXER 0 ++#define CONFIG_SER_DEMUXER 0 ++#define CONFIG_SHORTEN_DEMUXER 0 ++#define CONFIG_SIFF_DEMUXER 0 ++#define CONFIG_SLN_DEMUXER 0 ++#define CONFIG_SMACKER_DEMUXER 0 ++#define CONFIG_SMJPEG_DEMUXER 0 ++#define CONFIG_SMUSH_DEMUXER 0 ++#define CONFIG_SOL_DEMUXER 0 ++#define CONFIG_SOX_DEMUXER 0 ++#define CONFIG_SPDIF_DEMUXER 0 ++#define CONFIG_SRT_DEMUXER 0 ++#define CONFIG_STR_DEMUXER 0 ++#define CONFIG_STL_DEMUXER 0 ++#define CONFIG_SUBVIEWER1_DEMUXER 0 ++#define CONFIG_SUBVIEWER_DEMUXER 0 ++#define CONFIG_SUP_DEMUXER 0 ++#define CONFIG_SVAG_DEMUXER 0 ++#define CONFIG_SWF_DEMUXER 0 ++#define CONFIG_TAK_DEMUXER 0 ++#define CONFIG_TEDCAPTIONS_DEMUXER 0 ++#define CONFIG_THP_DEMUXER 0 ++#define CONFIG_THREEDOSTR_DEMUXER 0 ++#define CONFIG_TIERTEXSEQ_DEMUXER 0 ++#define CONFIG_TMV_DEMUXER 0 ++#define CONFIG_TRUEHD_DEMUXER 0 ++#define CONFIG_TTA_DEMUXER 0 ++#define CONFIG_TXD_DEMUXER 0 ++#define CONFIG_TTY_DEMUXER 0 ++#define CONFIG_TY_DEMUXER 0 ++#define CONFIG_V210_DEMUXER 0 ++#define CONFIG_V210X_DEMUXER 0 ++#define CONFIG_VAG_DEMUXER 0 ++#define CONFIG_VC1_DEMUXER 0 ++#define CONFIG_VC1T_DEMUXER 0 ++#define CONFIG_VIVO_DEMUXER 0 ++#define CONFIG_VMD_DEMUXER 0 ++#define CONFIG_VOBSUB_DEMUXER 0 ++#define CONFIG_VOC_DEMUXER 0 ++#define CONFIG_VPK_DEMUXER 0 ++#define CONFIG_VPLAYER_DEMUXER 0 ++#define CONFIG_VQF_DEMUXER 0 ++#define CONFIG_W64_DEMUXER 0 ++#define CONFIG_WAV_DEMUXER 1 ++#define CONFIG_WC3_DEMUXER 0 ++#define CONFIG_WEBM_DASH_MANIFEST_DEMUXER 0 ++#define CONFIG_WEBVTT_DEMUXER 0 ++#define CONFIG_WSAUD_DEMUXER 0 ++#define CONFIG_WSD_DEMUXER 0 ++#define CONFIG_WSVQA_DEMUXER 0 ++#define CONFIG_WTV_DEMUXER 0 ++#define CONFIG_WVE_DEMUXER 0 ++#define CONFIG_WV_DEMUXER 0 ++#define CONFIG_XA_DEMUXER 0 ++#define CONFIG_XBIN_DEMUXER 0 ++#define CONFIG_XMV_DEMUXER 0 ++#define CONFIG_XVAG_DEMUXER 0 ++#define CONFIG_XWMA_DEMUXER 0 ++#define CONFIG_YOP_DEMUXER 0 ++#define CONFIG_YUV4MPEGPIPE_DEMUXER 0 ++#define CONFIG_IMAGE_BMP_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_DDS_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_DPX_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_EXR_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_J2K_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_JPEG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_JPEGLS_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PAM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PBM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PCX_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PGMYUV_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PGM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PICTOR_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PNG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PPM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_PSD_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_QDRAW_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SGI_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SVG_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_SUNRAST_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_TIFF_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_WEBP_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_XPM_PIPE_DEMUXER 0 ++#define CONFIG_IMAGE_XWD_PIPE_DEMUXER 0 ++#define CONFIG_LIBGME_DEMUXER 0 ++#define CONFIG_LIBMODPLUG_DEMUXER 0 ++#define CONFIG_LIBOPENMPT_DEMUXER 0 ++#define CONFIG_VAPOURSYNTH_DEMUXER 0 ++#define CONFIG_A64_MUXER 0 ++#define CONFIG_AC3_MUXER 0 ++#define CONFIG_ADTS_MUXER 0 ++#define CONFIG_ADX_MUXER 0 ++#define CONFIG_AIFF_MUXER 0 ++#define CONFIG_AMR_MUXER 0 ++#define CONFIG_APNG_MUXER 0 ++#define CONFIG_APTX_MUXER 0 ++#define CONFIG_APTX_HD_MUXER 0 ++#define CONFIG_ASF_MUXER 0 ++#define CONFIG_ASS_MUXER 0 ++#define CONFIG_AST_MUXER 0 ++#define CONFIG_ASF_STREAM_MUXER 0 ++#define CONFIG_AU_MUXER 0 ++#define CONFIG_AVI_MUXER 0 ++#define CONFIG_AVM2_MUXER 0 ++#define CONFIG_AVS2_MUXER 0 ++#define CONFIG_BIT_MUXER 0 ++#define CONFIG_CAF_MUXER 0 ++#define CONFIG_CAVSVIDEO_MUXER 0 ++#define CONFIG_CODEC2_MUXER 0 ++#define CONFIG_CODEC2RAW_MUXER 0 ++#define CONFIG_CRC_MUXER 0 ++#define CONFIG_DASH_MUXER 0 ++#define CONFIG_DATA_MUXER 0 ++#define CONFIG_DAUD_MUXER 0 ++#define CONFIG_DIRAC_MUXER 0 ++#define CONFIG_DNXHD_MUXER 0 ++#define CONFIG_DTS_MUXER 0 ++#define CONFIG_DV_MUXER 0 ++#define CONFIG_EAC3_MUXER 0 ++#define CONFIG_F4V_MUXER 0 ++#define CONFIG_FFMETADATA_MUXER 0 ++#define CONFIG_FIFO_MUXER 0 ++#define CONFIG_FIFO_TEST_MUXER 0 ++#define CONFIG_FILMSTRIP_MUXER 0 ++#define CONFIG_FITS_MUXER 0 ++#define CONFIG_FLAC_MUXER 0 ++#define CONFIG_FLV_MUXER 0 ++#define CONFIG_FRAMECRC_MUXER 0 ++#define CONFIG_FRAMEHASH_MUXER 0 ++#define CONFIG_FRAMEMD5_MUXER 0 ++#define CONFIG_G722_MUXER 0 ++#define CONFIG_G723_1_MUXER 0 ++#define CONFIG_G726_MUXER 0 ++#define CONFIG_G726LE_MUXER 0 ++#define CONFIG_GIF_MUXER 0 ++#define CONFIG_GSM_MUXER 0 ++#define CONFIG_GXF_MUXER 0 ++#define CONFIG_H261_MUXER 0 ++#define CONFIG_H263_MUXER 0 ++#define CONFIG_H264_MUXER 0 ++#define CONFIG_HASH_MUXER 0 ++#define CONFIG_HDS_MUXER 0 ++#define CONFIG_HEVC_MUXER 0 ++#define CONFIG_HLS_MUXER 0 ++#define CONFIG_ICO_MUXER 0 ++#define CONFIG_ILBC_MUXER 0 ++#define CONFIG_IMAGE2_MUXER 0 ++#define CONFIG_IMAGE2PIPE_MUXER 0 ++#define CONFIG_IPOD_MUXER 0 ++#define CONFIG_IRCAM_MUXER 0 ++#define CONFIG_ISMV_MUXER 0 ++#define CONFIG_IVF_MUXER 0 ++#define CONFIG_JACOSUB_MUXER 0 ++#define CONFIG_LATM_MUXER 0 ++#define CONFIG_LRC_MUXER 0 ++#define CONFIG_M4V_MUXER 0 ++#define CONFIG_MD5_MUXER 0 ++#define CONFIG_MATROSKA_MUXER 0 ++#define CONFIG_MATROSKA_AUDIO_MUXER 0 ++#define CONFIG_MICRODVD_MUXER 0 ++#define CONFIG_MJPEG_MUXER 0 ++#define CONFIG_MLP_MUXER 0 ++#define CONFIG_MMF_MUXER 0 ++#define CONFIG_MOV_MUXER 0 ++#define CONFIG_MP2_MUXER 0 ++#define CONFIG_MP3_MUXER 0 ++#define CONFIG_MP4_MUXER 0 ++#define CONFIG_MPEG1SYSTEM_MUXER 0 ++#define CONFIG_MPEG1VCD_MUXER 0 ++#define CONFIG_MPEG1VIDEO_MUXER 0 ++#define CONFIG_MPEG2DVD_MUXER 0 ++#define CONFIG_MPEG2SVCD_MUXER 0 ++#define CONFIG_MPEG2VIDEO_MUXER 0 ++#define CONFIG_MPEG2VOB_MUXER 0 ++#define CONFIG_MPEGTS_MUXER 0 ++#define CONFIG_MPJPEG_MUXER 0 ++#define CONFIG_MXF_MUXER 0 ++#define CONFIG_MXF_D10_MUXER 0 ++#define CONFIG_MXF_OPATOM_MUXER 0 ++#define CONFIG_NULL_MUXER 0 ++#define CONFIG_NUT_MUXER 0 ++#define CONFIG_OGA_MUXER 0 ++#define CONFIG_OGG_MUXER 0 ++#define CONFIG_OGV_MUXER 0 ++#define CONFIG_OMA_MUXER 0 ++#define CONFIG_OPUS_MUXER 0 ++#define CONFIG_PCM_ALAW_MUXER 0 ++#define CONFIG_PCM_MULAW_MUXER 0 ++#define CONFIG_PCM_VIDC_MUXER 0 ++#define CONFIG_PCM_F64BE_MUXER 0 ++#define CONFIG_PCM_F64LE_MUXER 0 ++#define CONFIG_PCM_F32BE_MUXER 0 ++#define CONFIG_PCM_F32LE_MUXER 0 ++#define CONFIG_PCM_S32BE_MUXER 0 ++#define CONFIG_PCM_S32LE_MUXER 0 ++#define CONFIG_PCM_S24BE_MUXER 0 ++#define CONFIG_PCM_S24LE_MUXER 0 ++#define CONFIG_PCM_S16BE_MUXER 0 ++#define CONFIG_PCM_S16LE_MUXER 0 ++#define CONFIG_PCM_S8_MUXER 0 ++#define CONFIG_PCM_U32BE_MUXER 0 ++#define CONFIG_PCM_U32LE_MUXER 0 ++#define CONFIG_PCM_U24BE_MUXER 0 ++#define CONFIG_PCM_U24LE_MUXER 0 ++#define CONFIG_PCM_U16BE_MUXER 0 ++#define CONFIG_PCM_U16LE_MUXER 0 ++#define CONFIG_PCM_U8_MUXER 0 ++#define CONFIG_PSP_MUXER 0 ++#define CONFIG_RAWVIDEO_MUXER 0 ++#define CONFIG_RM_MUXER 0 ++#define CONFIG_ROQ_MUXER 0 ++#define CONFIG_RSO_MUXER 0 ++#define CONFIG_RTP_MUXER 0 ++#define CONFIG_RTP_MPEGTS_MUXER 0 ++#define CONFIG_RTSP_MUXER 0 ++#define CONFIG_SAP_MUXER 0 ++#define CONFIG_SBC_MUXER 0 ++#define CONFIG_SCC_MUXER 0 ++#define CONFIG_SEGAFILM_MUXER 0 ++#define CONFIG_SEGMENT_MUXER 0 ++#define CONFIG_STREAM_SEGMENT_MUXER 0 ++#define CONFIG_SINGLEJPEG_MUXER 0 ++#define CONFIG_SMJPEG_MUXER 0 ++#define CONFIG_SMOOTHSTREAMING_MUXER 0 ++#define CONFIG_SOX_MUXER 0 ++#define CONFIG_SPX_MUXER 0 ++#define CONFIG_SPDIF_MUXER 0 ++#define CONFIG_SRT_MUXER 0 ++#define CONFIG_SUP_MUXER 0 ++#define CONFIG_SWF_MUXER 0 ++#define CONFIG_TEE_MUXER 0 ++#define CONFIG_TG2_MUXER 0 ++#define CONFIG_TGP_MUXER 0 ++#define CONFIG_MKVTIMESTAMP_V2_MUXER 0 ++#define CONFIG_TRUEHD_MUXER 0 ++#define CONFIG_TTA_MUXER 0 ++#define CONFIG_UNCODEDFRAMECRC_MUXER 0 ++#define CONFIG_VC1_MUXER 0 ++#define CONFIG_VC1T_MUXER 0 ++#define CONFIG_VOC_MUXER 0 ++#define CONFIG_W64_MUXER 0 ++#define CONFIG_WAV_MUXER 0 ++#define CONFIG_WEBM_MUXER 0 ++#define CONFIG_WEBM_DASH_MANIFEST_MUXER 0 ++#define CONFIG_WEBM_CHUNK_MUXER 0 ++#define CONFIG_WEBP_MUXER 0 ++#define CONFIG_WEBVTT_MUXER 0 ++#define CONFIG_WTV_MUXER 0 ++#define CONFIG_WV_MUXER 0 ++#define CONFIG_YUV4MPEGPIPE_MUXER 0 ++#define CONFIG_CHROMAPRINT_MUXER 0 ++#define CONFIG_ASYNC_PROTOCOL 0 ++#define CONFIG_BLURAY_PROTOCOL 0 ++#define CONFIG_CACHE_PROTOCOL 0 ++#define CONFIG_CONCAT_PROTOCOL 0 ++#define CONFIG_CRYPTO_PROTOCOL 0 ++#define CONFIG_DATA_PROTOCOL 0 ++#define CONFIG_FFRTMPCRYPT_PROTOCOL 0 ++#define CONFIG_FFRTMPHTTP_PROTOCOL 0 ++#define CONFIG_FILE_PROTOCOL 0 ++#define CONFIG_FTP_PROTOCOL 0 ++#define CONFIG_GOPHER_PROTOCOL 0 ++#define CONFIG_HLS_PROTOCOL 0 ++#define CONFIG_HTTP_PROTOCOL 0 ++#define CONFIG_HTTPPROXY_PROTOCOL 0 ++#define CONFIG_HTTPS_PROTOCOL 0 ++#define CONFIG_ICECAST_PROTOCOL 0 ++#define CONFIG_MMSH_PROTOCOL 0 ++#define CONFIG_MMST_PROTOCOL 0 ++#define CONFIG_MD5_PROTOCOL 0 ++#define CONFIG_PIPE_PROTOCOL 0 ++#define CONFIG_PROMPEG_PROTOCOL 0 ++#define CONFIG_RTMP_PROTOCOL 0 ++#define CONFIG_RTMPE_PROTOCOL 0 ++#define CONFIG_RTMPS_PROTOCOL 0 ++#define CONFIG_RTMPT_PROTOCOL 0 ++#define CONFIG_RTMPTE_PROTOCOL 0 ++#define CONFIG_RTMPTS_PROTOCOL 0 ++#define CONFIG_RTP_PROTOCOL 0 ++#define CONFIG_SCTP_PROTOCOL 0 ++#define CONFIG_SRTP_PROTOCOL 0 ++#define CONFIG_SUBFILE_PROTOCOL 0 ++#define CONFIG_TEE_PROTOCOL 0 ++#define CONFIG_TCP_PROTOCOL 0 ++#define CONFIG_TLS_PROTOCOL 0 ++#define CONFIG_UDP_PROTOCOL 0 ++#define CONFIG_UDPLITE_PROTOCOL 0 ++#define CONFIG_UNIX_PROTOCOL 0 ++#define CONFIG_LIBRTMP_PROTOCOL 0 ++#define CONFIG_LIBRTMPE_PROTOCOL 0 ++#define CONFIG_LIBRTMPS_PROTOCOL 0 ++#define CONFIG_LIBRTMPT_PROTOCOL 0 ++#define CONFIG_LIBRTMPTE_PROTOCOL 0 ++#define CONFIG_LIBSRT_PROTOCOL 0 ++#define CONFIG_LIBSSH_PROTOCOL 0 ++#define CONFIG_LIBSMBCLIENT_PROTOCOL 0 ++#endif /* FFMPEG_CONFIG_H */ +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/bsf_list.c b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/bsf_list.c +new file mode 100644 +index 00000000000..d31ece942a7 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/bsf_list.c +@@ -0,0 +1,3 @@ ++static const AVBitStreamFilter * const bitstream_filters[] = { ++ &ff_null_bsf, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/codec_list.c b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/codec_list.c +new file mode 100644 +index 00000000000..9407bd2775e +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/codec_list.c +@@ -0,0 +1,18 @@ ++static const AVCodec * const codec_list[] = { ++ &ff_theora_decoder, ++ &ff_vp3_decoder, ++ &ff_vp8_decoder, ++ &ff_flac_decoder, ++ &ff_mp3_decoder, ++ &ff_vorbis_decoder, ++ &ff_pcm_alaw_decoder, ++ &ff_pcm_f32le_decoder, ++ &ff_pcm_mulaw_decoder, ++ &ff_pcm_s16be_decoder, ++ &ff_pcm_s16le_decoder, ++ &ff_pcm_s24be_decoder, ++ &ff_pcm_s24le_decoder, ++ &ff_pcm_s32le_decoder, ++ &ff_pcm_u8_decoder, ++ &ff_libopus_decoder, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/parser_list.c b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/parser_list.c +new file mode 100644 +index 00000000000..4c59b89cdf8 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavcodec/parser_list.c +@@ -0,0 +1,8 @@ ++static const AVCodecParser * const parser_list[] = { ++ &ff_flac_parser, ++ &ff_mpegaudio_parser, ++ &ff_opus_parser, ++ &ff_vorbis_parser, ++ &ff_vp3_parser, ++ &ff_vp8_parser, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/demuxer_list.c b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/demuxer_list.c +new file mode 100644 +index 00000000000..1908ba19e77 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/demuxer_list.c +@@ -0,0 +1,8 @@ ++static const AVInputFormat * const demuxer_list[] = { ++ &ff_flac_demuxer, ++ &ff_matroska_demuxer, ++ &ff_mov_demuxer, ++ &ff_mp3_demuxer, ++ &ff_ogg_demuxer, ++ &ff_wav_demuxer, ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/muxer_list.c b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/muxer_list.c +new file mode 100644 +index 00000000000..f36d9499c6f +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/muxer_list.c +@@ -0,0 +1,2 @@ ++static const AVOutputFormat * const muxer_list[] = { ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/protocol_list.c b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/protocol_list.c +new file mode 100644 +index 00000000000..247e1e4c3a2 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavformat/protocol_list.c +@@ -0,0 +1,2 @@ ++static const URLProtocol * const url_protocols[] = { ++ NULL }; +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavutil/avconfig.h b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavutil/avconfig.h +new file mode 100644 +index 00000000000..c289fbb551c +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavutil/avconfig.h +@@ -0,0 +1,6 @@ ++/* Generated by ffmpeg configure */ ++#ifndef AVUTIL_AVCONFIG_H ++#define AVUTIL_AVCONFIG_H ++#define AV_HAVE_BIGENDIAN 0 ++#define AV_HAVE_FAST_UNALIGNED 1 ++#endif /* AVUTIL_AVCONFIG_H */ +diff --git a/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavutil/ffversion.h b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavutil/ffversion.h +new file mode 100644 +index 00000000000..9d3dbe8cc2a +--- /dev/null ++++ b/chromium/third_party/ffmpeg/chromium/config/Chromium/linux/ppc64/libavutil/ffversion.h +@@ -0,0 +1,5 @@ ++/* Automatically generated by version.sh, do not manually edit! */ ++#ifndef AVUTIL_FFVERSION_H ++#define AVUTIL_FFVERSION_H ++#define FFMPEG_VERSION "git-2020-01-07-ccf3ef182a0" ++#endif /* AVUTIL_FFVERSION_H */ +diff --git a/chromium/third_party/ffmpeg/ffmpeg_generated.gni.ppc64 b/chromium/third_party/ffmpeg/ffmpeg_generated.gni.ppc64 +new file mode 100644 +index 00000000000..2c056cc207e +--- /dev/null ++++ b/chromium/third_party/ffmpeg/ffmpeg_generated.gni.ppc64 +@@ -0,0 +1,319 @@ ++# Copyright 2020 The Chromium Authors. All rights reserved. ++# Use of this source code is governed by a BSD-style license that can be ++# found in the LICENSE file. ++ ++# NOTE: this file is autogenerated by ffmpeg/chromium/scripts/generate_gn.py ++ ++import("//build/config/arm.gni") ++import("ffmpeg_options.gni") ++ ++# Declare empty versions of each variable for easier +=ing later. ++ffmpeg_c_sources = [] ++ffmpeg_gas_sources = [] ++ffmpeg_asm_sources = [] ++ ++use_linux_config = is_linux || is_fuchsia ++ ++if (use_linux_config && current_cpu == "ppc64") { ++ ffmpeg_c_sources += [ ++ "libavcodec/ac3_parser.c", ++ "libavcodec/ac3tab.c", ++ "libavcodec/adts_parser.c", ++ "libavcodec/allcodecs.c", ++ "libavcodec/autorename_libavcodec_flacdec.c", ++ "libavcodec/autorename_libavcodec_utils.c", ++ "libavcodec/autorename_libavcodec_videodsp.c", ++ "libavcodec/avdct.c", ++ "libavcodec/avfft.c", ++ "libavcodec/avpacket.c", ++ "libavcodec/avpicture.c", ++ "libavcodec/bitstream.c", ++ "libavcodec/bitstream_filter.c", ++ "libavcodec/bitstream_filters.c", ++ "libavcodec/bsf.c", ++ "libavcodec/codec_desc.c", ++ "libavcodec/d3d11va.c", ++ "libavcodec/dct.c", ++ "libavcodec/dct32_fixed.c", ++ "libavcodec/dct32_float.c", ++ "libavcodec/decode.c", ++ "libavcodec/dirac.c", ++ "libavcodec/dv_profile.c", ++ "libavcodec/encode.c", ++ "libavcodec/fft_fixed.c", ++ "libavcodec/fft_fixed_32.c", ++ "libavcodec/fft_float.c", ++ "libavcodec/fft_init_table.c", ++ "libavcodec/flac.c", ++ "libavcodec/flac_parser.c", ++ "libavcodec/flacdata.c", ++ "libavcodec/flacdsp.c", ++ "libavcodec/golomb.c", ++ "libavcodec/h264pred.c", ++ "libavcodec/hpeldsp.c", ++ "libavcodec/imgconvert.c", ++ "libavcodec/jni.c", ++ "libavcodec/libopus.c", ++ "libavcodec/libopusdec.c", ++ "libavcodec/mathtables.c", ++ "libavcodec/mdct_fixed.c", ++ "libavcodec/mdct_fixed_32.c", ++ "libavcodec/mdct_float.c", ++ "libavcodec/mediacodec.c", ++ "libavcodec/mjpegenc_huffman.c", ++ "libavcodec/mpeg12framerate.c", ++ "libavcodec/mpeg4audio.c", ++ "libavcodec/mpegaudio.c", ++ "libavcodec/mpegaudio_parser.c", ++ "libavcodec/mpegaudiodata.c", ++ "libavcodec/mpegaudiodec_fixed.c", ++ "libavcodec/mpegaudiodecheader.c", ++ "libavcodec/mpegaudiodsp.c", ++ "libavcodec/mpegaudiodsp_data.c", ++ "libavcodec/mpegaudiodsp_fixed.c", ++ "libavcodec/mpegaudiodsp_float.c", ++ "libavcodec/null_bsf.c", ++ "libavcodec/options.c", ++ "libavcodec/opus.c", ++ "libavcodec/opus_parser.c", ++ "libavcodec/opus_rc.c", ++ "libavcodec/opustab.c", ++ "libavcodec/parser.c", ++ "libavcodec/parsers.c", ++ "libavcodec/pcm.c", ++ "libavcodec/ppc/fft_init.c", ++ "libavcodec/ppc/fft_vsx.c", ++ "libavcodec/ppc/hpeldsp_altivec.c", ++ "libavcodec/ppc/mpegaudiodsp_altivec.c", ++ "libavcodec/ppc/videodsp.c", ++ "libavcodec/ppc/vorbisdsp_altivec.c", ++ "libavcodec/ppc/vp3dsp_altivec.c", ++ "libavcodec/ppc/vp8dsp_altivec.c", ++ "libavcodec/profiles.c", ++ "libavcodec/pthread.c", ++ "libavcodec/pthread_frame.c", ++ "libavcodec/pthread_slice.c", ++ "libavcodec/qsv_api.c", ++ "libavcodec/raw.c", ++ "libavcodec/rdft.c", ++ "libavcodec/vorbis.c", ++ "libavcodec/vorbis_data.c", ++ "libavcodec/vorbis_parser.c", ++ "libavcodec/vorbisdec.c", ++ "libavcodec/vorbisdsp.c", ++ "libavcodec/vp3.c", ++ "libavcodec/vp3_parser.c", ++ "libavcodec/vp3dsp.c", ++ "libavcodec/vp56rac.c", ++ "libavcodec/vp8.c", ++ "libavcodec/vp8_parser.c", ++ "libavcodec/vp8dsp.c", ++ "libavcodec/xiph.c", ++ "libavformat/allformats.c", ++ "libavformat/autorename_libavformat_options.c", ++ "libavformat/autorename_libavformat_pcm.c", ++ "libavformat/autorename_libavformat_utils.c", ++ "libavformat/avio.c", ++ "libavformat/aviobuf.c", ++ "libavformat/cutils.c", ++ "libavformat/dump.c", ++ "libavformat/flac_picture.c", ++ "libavformat/flacdec.c", ++ "libavformat/format.c", ++ "libavformat/id3v1.c", ++ "libavformat/id3v2.c", ++ "libavformat/isom.c", ++ "libavformat/matroska.c", ++ "libavformat/matroskadec.c", ++ "libavformat/metadata.c", ++ "libavformat/mov.c", ++ "libavformat/mov_chan.c", ++ "libavformat/mov_esds.c", ++ "libavformat/mp3dec.c", ++ "libavformat/mux.c", ++ "libavformat/oggdec.c", ++ "libavformat/oggparseflac.c", ++ "libavformat/oggparseogm.c", ++ "libavformat/oggparseopus.c", ++ "libavformat/oggparseskeleton.c", ++ "libavformat/oggparsetheora.c", ++ "libavformat/oggparsevorbis.c", ++ "libavformat/oggparsevp8.c", ++ "libavformat/os_support.c", ++ "libavformat/protocols.c", ++ "libavformat/qtpalette.c", ++ "libavformat/rawdec.c", ++ "libavformat/replaygain.c", ++ "libavformat/riff.c", ++ "libavformat/riffdec.c", ++ "libavformat/rmsipr.c", ++ "libavformat/url.c", ++ "libavformat/vorbiscomment.c", ++ "libavformat/wavdec.c", ++ "libavutil/aes.c", ++ "libavutil/aes_ctr.c", ++ "libavutil/avsscanf.c", ++ "libavutil/avstring.c", ++ "libavutil/base64.c", ++ "libavutil/bprint.c", ++ "libavutil/buffer.c", ++ "libavutil/camellia.c", ++ "libavutil/channel_layout.c", ++ "libavutil/color_utils.c", ++ "libavutil/cpu.c", ++ "libavutil/crc.c", ++ "libavutil/dict.c", ++ "libavutil/display.c", ++ "libavutil/downmix_info.c", ++ "libavutil/encryption_info.c", ++ "libavutil/error.c", ++ "libavutil/eval.c", ++ "libavutil/fifo.c", ++ "libavutil/file_open.c", ++ "libavutil/fixed_dsp.c", ++ "libavutil/float_dsp.c", ++ "libavutil/frame.c", ++ "libavutil/hwcontext.c", ++ "libavutil/imgutils.c", ++ "libavutil/integer.c", ++ "libavutil/intmath.c", ++ "libavutil/lfg.c", ++ "libavutil/log.c", ++ "libavutil/log2_tab.c", ++ "libavutil/mastering_display_metadata.c", ++ "libavutil/mathematics.c", ++ "libavutil/md5.c", ++ "libavutil/mem.c", ++ "libavutil/opt.c", ++ "libavutil/parseutils.c", ++ "libavutil/pixdesc.c", ++ "libavutil/pixelutils.c", ++ "libavutil/ppc/autorename_libavutil_ppc_cpu.c", ++ "libavutil/ppc/float_dsp_altivec.c", ++ "libavutil/ppc/float_dsp_init.c", ++ "libavutil/ppc/float_dsp_vsx.c", ++ "libavutil/random_seed.c", ++ "libavutil/rational.c", ++ "libavutil/reverse.c", ++ "libavutil/samplefmt.c", ++ "libavutil/sha.c", ++ "libavutil/slicethread.c", ++ "libavutil/spherical.c", ++ "libavutil/stereo3d.c", ++ "libavutil/tea.c", ++ "libavutil/threadmessage.c", ++ "libavutil/time.c", ++ "libavutil/timecode.c", ++ "libavutil/twofish.c", ++ "libavutil/utils.c", ++ ] ++ ffmpeg_gas_sources += [ ++ "libavcodec/ppc/fft_altivec.S", ++ ] ++} ++ ++if ((use_linux_config && current_cpu == "ppc64" && ffmpeg_branding == "Chrome") || (use_linux_config && current_cpu == "ppc64" && ffmpeg_branding == "ChromeOS")) { ++ ffmpeg_c_sources += [ ++ "libavcodec/aac_ac3_parser.c", ++ "libavcodec/aac_parser.c", ++ "libavcodec/aacps_float.c", ++ "libavcodec/aacpsdsp_float.c", ++ "libavcodec/aacsbr.c", ++ "libavcodec/aactab.c", ++ "libavcodec/adts_header.c", ++ "libavcodec/autorename_libavcodec_aacdec.c", ++ "libavcodec/autorename_libavcodec_h264dsp.c", ++ "libavcodec/autorename_libavcodec_h264qpel.c", ++ "libavcodec/cabac.c", ++ "libavcodec/cbrt_data.c", ++ "libavcodec/h2645_parse.c", ++ "libavcodec/h264_cabac.c", ++ "libavcodec/h264_cavlc.c", ++ "libavcodec/h264_direct.c", ++ "libavcodec/h264_loopfilter.c", ++ "libavcodec/h264_mb.c", ++ "libavcodec/h264_parse.c", ++ "libavcodec/h264_parser.c", ++ "libavcodec/h264_picture.c", ++ "libavcodec/h264_ps.c", ++ "libavcodec/h264_refs.c", ++ "libavcodec/h264_sei.c", ++ "libavcodec/h264_slice.c", ++ "libavcodec/h264chroma.c", ++ "libavcodec/h264data.c", ++ "libavcodec/h264dec.c", ++ "libavcodec/h264idct.c", ++ "libavcodec/kbdwin.c", ++ "libavcodec/mdct15.c", ++ "libavcodec/ppc/h264chroma_init.c", ++ "libavcodec/ppc/h264dsp.c", ++ "libavcodec/ppc/h264qpel.c", ++ "libavcodec/sbrdsp.c", ++ "libavcodec/sinewin.c", ++ "libavcodec/sinewin_fixed.c", ++ "libavcodec/startcode.c", ++ "libavformat/aacdec.c", ++ "libavformat/apetag.c", ++ "libavformat/img2.c", ++ ] ++} ++ ++if (use_linux_config && current_cpu == "ppc64" && ffmpeg_branding == "ChromeOS") { ++ ffmpeg_c_sources += [ ++ "libavcodec/acelp_filters.c", ++ "libavcodec/acelp_pitch_delay.c", ++ "libavcodec/acelp_vectors.c", ++ "libavcodec/amrnbdec.c", ++ "libavcodec/amrwbdec.c", ++ "libavcodec/autorename_libavcodec_blockdsp.c", ++ "libavcodec/autorename_libavcodec_fdctdsp.c", ++ "libavcodec/autorename_libavcodec_mpegvideodsp.c", ++ "libavcodec/autorename_libavcodec_pixblockdsp.c", ++ "libavcodec/celp_filters.c", ++ "libavcodec/celp_math.c", ++ "libavcodec/error_resilience.c", ++ "libavcodec/exif.c", ++ "libavcodec/flvdec.c", ++ "libavcodec/gsm_parser.c", ++ "libavcodec/gsmdec.c", ++ "libavcodec/gsmdec_data.c", ++ "libavcodec/h263.c", ++ "libavcodec/h263_parser.c", ++ "libavcodec/h263data.c", ++ "libavcodec/h263dec.c", ++ "libavcodec/h263dsp.c", ++ "libavcodec/idctdsp.c", ++ "libavcodec/intelh263dec.c", ++ "libavcodec/ituh263dec.c", ++ "libavcodec/jfdctfst.c", ++ "libavcodec/jfdctint.c", ++ "libavcodec/jrevdct.c", ++ "libavcodec/lsp.c", ++ "libavcodec/me_cmp.c", ++ "libavcodec/mpeg4video.c", ++ "libavcodec/mpeg4video_parser.c", ++ "libavcodec/mpeg4videodec.c", ++ "libavcodec/mpeg_er.c", ++ "libavcodec/mpegpicture.c", ++ "libavcodec/mpegutils.c", ++ "libavcodec/mpegvideo.c", ++ "libavcodec/mpegvideo_motion.c", ++ "libavcodec/mpegvideodata.c", ++ "libavcodec/msgsmdec.c", ++ "libavcodec/ppc/autorename_libavcodec_ppc_idctdsp.c", ++ "libavcodec/ppc/autorename_libavcodec_ppc_me_cmp.c", ++ "libavcodec/ppc/blockdsp.c", ++ "libavcodec/ppc/fdctdsp.c", ++ "libavcodec/ppc/mpegvideo_altivec.c", ++ "libavcodec/ppc/mpegvideodsp.c", ++ "libavcodec/ppc/pixblockdsp.c", ++ "libavcodec/qpeldsp.c", ++ "libavcodec/rl.c", ++ "libavcodec/simple_idct.c", ++ "libavcodec/tiff_common.c", ++ "libavcodec/xvididct.c", ++ "libavformat/amr.c", ++ "libavformat/avidec.c", ++ ] ++} ++ +diff --git a/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_fdctdsp.c b/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_fdctdsp.c +new file mode 100644 +index 00000000000..6da44b5faad +--- /dev/null ++++ b/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_fdctdsp.c +@@ -0,0 +1,2 @@ ++// File automatically generated. See crbug.com/495833. ++#include "fdctdsp.c" +diff --git a/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_h264dsp.c b/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_h264dsp.c +new file mode 100644 +index 00000000000..253ba11f71e +--- /dev/null ++++ b/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_h264dsp.c +@@ -0,0 +1,2 @@ ++// File automatically generated. See crbug.com/495833. ++#include "h264dsp.c" +diff --git a/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_h264qpel.c b/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_h264qpel.c +new file mode 100644 +index 00000000000..19a60bdf88b +--- /dev/null ++++ b/chromium/third_party/ffmpeg/libavcodec/autorename_libavcodec_h264qpel.c +@@ -0,0 +1,2 @@ ++// File automatically generated. See crbug.com/495833. ++#include "h264qpel.c" +diff --git a/chromium/third_party/ffmpeg/libavcodec/ppc/autorename_libavcodec_ppc_idctdsp.c b/chromium/third_party/ffmpeg/libavcodec/ppc/autorename_libavcodec_ppc_idctdsp.c +new file mode 100644 +index 00000000000..c747a9457ac +--- /dev/null ++++ b/chromium/third_party/ffmpeg/libavcodec/ppc/autorename_libavcodec_ppc_idctdsp.c +@@ -0,0 +1,2 @@ ++// File automatically generated. See crbug.com/495833. ++#include "idctdsp.c" +diff --git a/chromium/third_party/ffmpeg/libavcodec/ppc/autorename_libavcodec_ppc_me_cmp.c b/chromium/third_party/ffmpeg/libavcodec/ppc/autorename_libavcodec_ppc_me_cmp.c +new file mode 100644 +index 00000000000..46db0f5dc96 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/libavcodec/ppc/autorename_libavcodec_ppc_me_cmp.c +@@ -0,0 +1,2 @@ ++// File automatically generated. See crbug.com/495833. ++#include "me_cmp.c" +diff --git a/chromium/third_party/ffmpeg/libavutil/ppc/autorename_libavutil_ppc_cpu.c b/chromium/third_party/ffmpeg/libavutil/ppc/autorename_libavutil_ppc_cpu.c +new file mode 100644 +index 00000000000..3adbdc6f778 +--- /dev/null ++++ b/chromium/third_party/ffmpeg/libavutil/ppc/autorename_libavutil_ppc_cpu.c +@@ -0,0 +1,2 @@ ++// File automatically generated. See crbug.com/495833. ++#include "cpu.c" +-- +2.21.1 + + +From d7de6a73bcfdf7c898f0063d61ead591cde2493e Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Dan=20Hor=C3=A1k?= +Date: Tue, 7 Jan 2020 17:44:59 +0100 +Subject: [PATCH 13/13] update third_party/blink for ppc64 + +--- + .../blink/renderer/platform/heap/asm/BUILD.gn | 4 ++ + .../platform/heap/asm/SaveRegisters_ppc64.S | 60 +++++++++++++++++++ + 2 files changed, 64 insertions(+) + create mode 100644 chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S + +diff --git a/chromium/third_party/blink/renderer/platform/heap/asm/BUILD.gn b/chromium/third_party/blink/renderer/platform/heap/asm/BUILD.gn +index 6c87950f41a..a2fab32b3c1 100644 +--- a/chromium/third_party/blink/renderer/platform/heap/asm/BUILD.gn ++++ b/chromium/third_party/blink/renderer/platform/heap/asm/BUILD.gn +@@ -46,6 +46,10 @@ if (current_cpu == "x86" || current_cpu == "x64") { + sources = [ + "SaveRegisters_mips64.S", + ] ++ } else if (current_cpu == "ppc64") { ++ sources = [ ++ "SaveRegisters_ppc64.S", ++ ] + } + + if (current_cpu == "arm") { +diff --git a/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S b/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S +new file mode 100644 +index 00000000000..44d0533696e +--- /dev/null ++++ b/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S +@@ -0,0 +1,60 @@ ++/* ++ * typedef void (*PushAllRegistersCallback)(SafePointBarrier*, ThreadState*, intptr_t*); ++ * extern "C" void PushAllRegisters(SafePointBarrier*, ThreadState*, PushAllRegistersCallback) ++ */ ++ ++.type PushAllRegisters, %function ++.global PushAllRegisters ++.hidden PushAllRegisters ++PushAllRegisters: ++ // Push all callee-saves registers to get them ++ // on the stack for conservative stack scanning. ++ // Reserve space for callee-saved registers and minimal stack frame. ++ mflr 0 # r0 = LR ++ std 0,16(1) # store LR at addr sp+16 ++ stdu 1,-176(1) # grow stack by 176 bytes and store new stack top ptr to r1 ++ # 3218*8 = min stack non-volatile registers ++ ++ // Save the callee-saved registers ++ std 31,168(1) # store r31 to addr sp+168 ++ std 30,160(1) # etc... ++ std 29,152(1) ++ std 28,144(1) ++ std 27,136(1) ++ std 26,128(1) ++ std 25,120(1) ++ std 24,112(1) ++ std 23,104(1) ++ std 22,96(1) ++ std 21,88(1) ++ std 20,80(1) ++ std 19,72(1) ++ std 18,64(1) ++ std 17,56(1) ++ std 16,48(1) ++ std 15,40(1) ++ std 14,32(1) ++ ++ // Note: the callee-saved floating point registers do not need to be ++ // copied to the stack, because fp registers never hold heap pointers ++ // and so do not need to be kept visible to the garbage collector. ++ ++ // Pass the two first arguments untouched in r3 and r4 and the ++ // stack pointer to the callback. ++ ++ std 2, 24(1) # save r2 to sp+24 addr ++ mtctr 5 # copy 3rd function arg (callback fn pointer) to CTR ++ mr 12, 5 # r12 must hold address of callback we are going to call ++ # for position-idependent functions inside the callback to work ++ mr 5, 1 # set current sp (stack top) as 3rd argument for the callback ++ bctrl # set LR to PC+4 and call the callback ++ ld 2, 24(1) # restore r2 from sp+24 addr ++ ++ // Adjust stack, restore return address and return. ++ // Note: the copied registers do not need to be reloaded here, ++ // because they were preserved by the called routine. ++ addi 1,1,176 # restore original SP by doing sp += 176 ++ ld 0,16(1) # restore original LR from addr sp+16 ++ mtlr 0 # ... copy it to the actual LR ++ blr # return to LR addr ++ +-- +2.21.1 +